From 8845b76ac40b36791c79618c5ee89f05d2d08c96 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= <kdy1997.dev@gmail.com>
Date: Mon, 19 Aug 2024 12:48:18 +0900
Subject: [PATCH] refactor(visit): Remove `VisitAll` (#9448)

**Description:**

Technically, this is a breaking change, but `VisitAll` was broken anyway, so I'll not mark this PR as a breaking change.

**Related issue:**

 - Closes https://github.com/swc-project/swc/issues/9337
---
 .changeset/real-pears-change.md               |      9 +
 crates/swc_css_visit/src/generated.rs         | 128750 +++++-------
 crates/swc_ecma_parser/tests/visitor.rs       |     40 -
 crates/swc_ecma_visit/src/generated.rs        | 162057 +++++++--------
 crates/swc_html_visit/src/generated.rs        |   1497 -
 crates/swc_xml_visit/src/generated.rs         |   1404 -
 tools/generate-code/src/generators/visitor.rs |     89 +-
 7 files changed, 129259 insertions(+), 164587 deletions(-)
 create mode 100644 .changeset/real-pears-change.md
 delete mode 100644 crates/swc_ecma_parser/tests/visitor.rs

diff --git a/.changeset/real-pears-change.md b/.changeset/real-pears-change.md
new file mode 100644
index 000000000000..61462c7625f8
--- /dev/null
+++ b/.changeset/real-pears-change.md
@@ -0,0 +1,9 @@
+---
+swc_core: patch
+swc_ecma_visit: patch
+swc_css_visit: patch
+swc_html_visit: patch
+swc_xml_visit: patch
+---
+
+refactor(visit): Remove `VisitAll`
diff --git a/crates/swc_css_visit/src/generated.rs b/crates/swc_css_visit/src/generated.rs
index c96243158ec0..5edde07afeaf 100644
--- a/crates/swc_css_visit/src/generated.rs
+++ b/crates/swc_css_visit/src/generated.rs
@@ -7820,19695 +7820,74 @@ where
         }
     }
 }
-impl<V> Visit for ::swc_visit::All<V>
-where
-    V: VisitAll,
-{
-    #[inline]
-    fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
-        <V as VisitAll>::visit_absolute_color_base(&mut self.visitor, node);
-        <AbsoluteColorBase as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_alpha_value(&mut self, node: &AlphaValue) {
-        <V as VisitAll>::visit_alpha_value(&mut self.visitor, node);
-        <AlphaValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_an_plus_b(&mut self, node: &AnPlusB) {
-        <V as VisitAll>::visit_an_plus_b(&mut self.visitor, node);
-        <AnPlusB as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
-        <V as VisitAll>::visit_an_plus_b_notation(&mut self.visitor, node);
-        <AnPlusBNotation as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_angle(&mut self, node: &Angle) {
-        <V as VisitAll>::visit_angle(&mut self.visitor, node);
-        <Angle as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
-        <V as VisitAll>::visit_angle_percentage(&mut self.visitor, node);
-        <AnglePercentage as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_any_namespace(&mut self, node: &AnyNamespace) {
-        <V as VisitAll>::visit_any_namespace(&mut self.visitor, node);
-        <AnyNamespace as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_at_rule(&mut self, node: &AtRule) {
-        <V as VisitAll>::visit_at_rule(&mut self.visitor, node);
-        <AtRule as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_at_rule_name(&mut self, node: &AtRuleName) {
-        <V as VisitAll>::visit_at_rule_name(&mut self.visitor, node);
-        <AtRuleName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
-        <V as VisitAll>::visit_at_rule_prelude(&mut self.visitor, node);
-        <AtRulePrelude as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut self.visitor, node);
-        <swc_atoms::Atom as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
-        <V as VisitAll>::visit_attribute_selector(&mut self.visitor, node);
-        <AttributeSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
-        <V as VisitAll>::visit_attribute_selector_matcher(&mut self.visitor, node);
-        <AttributeSelectorMatcher as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
-        <V as VisitAll>::visit_attribute_selector_matcher_value(&mut self.visitor, node);
-        <AttributeSelectorMatcherValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
-        <V as VisitAll>::visit_attribute_selector_modifier(&mut self.visitor, node);
-        <AttributeSelectorModifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
-        <V as VisitAll>::visit_attribute_selector_value(&mut self.visitor, node);
-        <AttributeSelectorValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_bin_op(&mut self, node: &BinOp) {
-        <V as VisitAll>::visit_bin_op(&mut self.visitor, node);
-        <BinOp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_operator(&mut self, node: &CalcOperator) {
-        <V as VisitAll>::visit_calc_operator(&mut self.visitor, node);
-        <CalcOperator as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
-        <V as VisitAll>::visit_calc_operator_type(&mut self.visitor, node);
-        <CalcOperatorType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_product(&mut self, node: &CalcProduct) {
-        <V as VisitAll>::visit_calc_product(&mut self.visitor, node);
-        <CalcProduct as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
-        <V as VisitAll>::visit_calc_product_or_operator(&mut self.visitor, node);
-        <CalcProductOrOperator as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
-        <V as VisitAll>::visit_calc_product_or_operators(&mut self.visitor, node);
-        <[CalcProductOrOperator] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_sum(&mut self, node: &CalcSum) {
-        <V as VisitAll>::visit_calc_sum(&mut self.visitor, node);
-        <CalcSum as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_value(&mut self, node: &CalcValue) {
-        <V as VisitAll>::visit_calc_value(&mut self.visitor, node);
-        <CalcValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
-        <V as VisitAll>::visit_calc_value_or_operator(&mut self.visitor, node);
-        <CalcValueOrOperator as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
-        <V as VisitAll>::visit_calc_value_or_operators(&mut self.visitor, node);
-        <[CalcValueOrOperator] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class_selector(&mut self, node: &ClassSelector) {
-        <V as VisitAll>::visit_class_selector(&mut self.visitor, node);
-        <ClassSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_cmyk_component(&mut self, node: &CmykComponent) {
-        <V as VisitAll>::visit_cmyk_component(&mut self.visitor, node);
-        <CmykComponent as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_color(&mut self, node: &Color) {
-        <V as VisitAll>::visit_color(&mut self.visitor, node);
-        <Color as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
-        <V as VisitAll>::visit_color_profile_name(&mut self.visitor, node);
-        <ColorProfileName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_combinator(&mut self, node: &Combinator) {
-        <V as VisitAll>::visit_combinator(&mut self.visitor, node);
-        <Combinator as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_combinator_value(&mut self, node: &CombinatorValue) {
-        <V as VisitAll>::visit_combinator_value(&mut self.visitor, node);
-        <CombinatorValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_complex_selector(&mut self, node: &ComplexSelector) {
-        <V as VisitAll>::visit_complex_selector(&mut self.visitor, node);
-        <ComplexSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
-        <V as VisitAll>::visit_complex_selector_children(&mut self.visitor, node);
-        <ComplexSelectorChildren as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
-        <V as VisitAll>::visit_complex_selector_childrens(&mut self.visitor, node);
-        <[ComplexSelectorChildren] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
-        <V as VisitAll>::visit_complex_selectors(&mut self.visitor, node);
-        <[ComplexSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_component_value(&mut self, node: &ComponentValue) {
-        <V as VisitAll>::visit_component_value(&mut self.visitor, node);
-        <ComponentValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_component_values(&mut self, node: &[ComponentValue]) {
-        <V as VisitAll>::visit_component_values(&mut self.visitor, node);
-        <[ComponentValue] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_compound_selector(&mut self, node: &CompoundSelector) {
-        <V as VisitAll>::visit_compound_selector(&mut self.visitor, node);
-        <CompoundSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
-        <V as VisitAll>::visit_compound_selector_list(&mut self.visitor, node);
-        <CompoundSelectorList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
-        <V as VisitAll>::visit_compound_selectors(&mut self.visitor, node);
-        <[CompoundSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_condition(&mut self, node: &ContainerCondition) {
-        <V as VisitAll>::visit_container_condition(&mut self.visitor, node);
-        <ContainerCondition as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_name(&mut self, node: &ContainerName) {
-        <V as VisitAll>::visit_container_name(&mut self.visitor, node);
-        <ContainerName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_query(&mut self, node: &ContainerQuery) {
-        <V as VisitAll>::visit_container_query(&mut self.visitor, node);
-        <ContainerQuery as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
-        <V as VisitAll>::visit_container_query_and(&mut self.visitor, node);
-        <ContainerQueryAnd as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
-        <V as VisitAll>::visit_container_query_not(&mut self.visitor, node);
-        <ContainerQueryNot as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
-        <V as VisitAll>::visit_container_query_or(&mut self.visitor, node);
-        <ContainerQueryOr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
-        <V as VisitAll>::visit_container_query_type(&mut self.visitor, node);
-        <ContainerQueryType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
-        <V as VisitAll>::visit_container_query_types(&mut self.visitor, node);
-        <[ContainerQueryType] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
-        <V as VisitAll>::visit_custom_highlight_name(&mut self.visitor, node);
-        <CustomHighlightName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_custom_ident(&mut self, node: &CustomIdent) {
-        <V as VisitAll>::visit_custom_ident(&mut self.visitor, node);
-        <CustomIdent as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
-        <V as VisitAll>::visit_custom_idents(&mut self.visitor, node);
-        <[CustomIdent] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
-        <V as VisitAll>::visit_custom_media_query(&mut self.visitor, node);
-        <CustomMediaQuery as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_custom_media_query_media_type(&mut self, node: &CustomMediaQueryMediaType) {
-        <V as VisitAll>::visit_custom_media_query_media_type(&mut self.visitor, node);
-        <CustomMediaQueryMediaType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
-        <V as VisitAll>::visit_custom_property_name(&mut self.visitor, node);
-        <CustomPropertyName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_dashed_ident(&mut self, node: &DashedIdent) {
-        <V as VisitAll>::visit_dashed_ident(&mut self.visitor, node);
-        <DashedIdent as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_declaration(&mut self, node: &Declaration) {
-        <V as VisitAll>::visit_declaration(&mut self.visitor, node);
-        <Declaration as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_declaration_name(&mut self, node: &DeclarationName) {
-        <V as VisitAll>::visit_declaration_name(&mut self.visitor, node);
-        <DeclarationName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
-        <V as VisitAll>::visit_declaration_or_at_rule(&mut self.visitor, node);
-        <DeclarationOrAtRule as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_delimiter(&mut self, node: &Delimiter) {
-        <V as VisitAll>::visit_delimiter(&mut self.visitor, node);
-        <Delimiter as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
-        <V as VisitAll>::visit_delimiter_value(&mut self.visitor, node);
-        <DelimiterValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_dimension(&mut self, node: &Dimension) {
-        <V as VisitAll>::visit_dimension(&mut self.visitor, node);
-        <Dimension as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_dimension_token(&mut self, node: &DimensionToken) {
-        <V as VisitAll>::visit_dimension_token(&mut self.visitor, node);
-        <DimensionToken as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
-        <V as VisitAll>::visit_document_prelude(&mut self.visitor, node);
-        <DocumentPrelude as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
-        <V as VisitAll>::visit_document_prelude_matching_function(&mut self.visitor, node);
-        <DocumentPreludeMatchingFunction as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_functions(
-        &mut self,
-        node: &[DocumentPreludeMatchingFunction],
-    ) {
-        <V as VisitAll>::visit_document_prelude_matching_functions(&mut self.visitor, node);
-        <[DocumentPreludeMatchingFunction] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_extension_name(&mut self, node: &ExtensionName) {
-        <V as VisitAll>::visit_extension_name(&mut self.visitor, node);
-        <ExtensionName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_family_name(&mut self, node: &FamilyName) {
-        <V as VisitAll>::visit_family_name(&mut self.visitor, node);
-        <FamilyName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_family_names(&mut self, node: &[FamilyName]) {
-        <V as VisitAll>::visit_family_names(&mut self.visitor, node);
-        <[FamilyName] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_flex(&mut self, node: &Flex) {
-        <V as VisitAll>::visit_flex(&mut self.visitor, node);
-        <Flex as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
-        <V as VisitAll>::visit_font_feature_values_prelude(&mut self.visitor, node);
-        <FontFeatureValuesPrelude as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
-        <V as VisitAll>::visit_forgiving_complex_selector(&mut self.visitor, node);
-        <ForgivingComplexSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
-        <V as VisitAll>::visit_forgiving_complex_selectors(&mut self.visitor, node);
-        <[ForgivingComplexSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
-        <V as VisitAll>::visit_forgiving_relative_selector(&mut self.visitor, node);
-        <ForgivingRelativeSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
-        <V as VisitAll>::visit_forgiving_relative_selector_list(&mut self.visitor, node);
-        <ForgivingRelativeSelectorList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
-        <V as VisitAll>::visit_forgiving_relative_selectors(&mut self.visitor, node);
-        <[ForgivingRelativeSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
-        <V as VisitAll>::visit_forgiving_selector_list(&mut self.visitor, node);
-        <ForgivingSelectorList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_frequency(&mut self, node: &Frequency) {
-        <V as VisitAll>::visit_frequency(&mut self.visitor, node);
-        <Frequency as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
-        <V as VisitAll>::visit_frequency_percentage(&mut self.visitor, node);
-        <FrequencyPercentage as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <V as VisitAll>::visit_function(&mut self.visitor, node);
-        <Function as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_function_name(&mut self, node: &FunctionName) {
-        <V as VisitAll>::visit_function_name(&mut self.visitor, node);
-        <FunctionName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
-        <V as VisitAll>::visit_general_enclosed(&mut self.visitor, node);
-        <GeneralEnclosed as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_hex_color(&mut self, node: &HexColor) {
-        <V as VisitAll>::visit_hex_color(&mut self.visitor, node);
-        <HexColor as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_hue(&mut self, node: &Hue) {
-        <V as VisitAll>::visit_hue(&mut self.visitor, node);
-        <Hue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_id_selector(&mut self, node: &IdSelector) {
-        <V as VisitAll>::visit_id_selector(&mut self.visitor, node);
-        <IdSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <V as VisitAll>::visit_ident(&mut self.visitor, node);
-        <Ident as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_idents(&mut self, node: &[Ident]) {
-        <V as VisitAll>::visit_idents(&mut self.visitor, node);
-        <[Ident] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_conditions(&mut self, node: &ImportConditions) {
-        <V as VisitAll>::visit_import_conditions(&mut self.visitor, node);
-        <ImportConditions as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_href(&mut self, node: &ImportHref) {
-        <V as VisitAll>::visit_import_href(&mut self.visitor, node);
-        <ImportHref as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
-        <V as VisitAll>::visit_import_layer_name(&mut self.visitor, node);
-        <ImportLayerName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_prelude(&mut self, node: &ImportPrelude) {
-        <V as VisitAll>::visit_import_prelude(&mut self.visitor, node);
-        <ImportPrelude as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_important_flag(&mut self, node: &ImportantFlag) {
-        <V as VisitAll>::visit_important_flag(&mut self.visitor, node);
-        <ImportantFlag as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_integer(&mut self, node: &Integer) {
-        <V as VisitAll>::visit_integer(&mut self.visitor, node);
-        <Integer as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
-        <V as VisitAll>::visit_keyframe_block(&mut self.visitor, node);
-        <KeyframeBlock as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
-        <V as VisitAll>::visit_keyframe_selector(&mut self.visitor, node);
-        <KeyframeSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
-        <V as VisitAll>::visit_keyframe_selectors(&mut self.visitor, node);
-        <[KeyframeSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_keyframes_name(&mut self, node: &KeyframesName) {
-        <V as VisitAll>::visit_keyframes_name(&mut self.visitor, node);
-        <KeyframesName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
-        <V as VisitAll>::visit_keyframes_pseudo_function(&mut self.visitor, node);
-        <KeyframesPseudoFunction as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
-        <V as VisitAll>::visit_keyframes_pseudo_prefix(&mut self.visitor, node);
-        <KeyframesPseudoPrefix as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_layer_name(&mut self, node: &LayerName) {
-        <V as VisitAll>::visit_layer_name(&mut self.visitor, node);
-        <LayerName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_layer_name_list(&mut self, node: &LayerNameList) {
-        <V as VisitAll>::visit_layer_name_list(&mut self.visitor, node);
-        <LayerNameList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_layer_names(&mut self, node: &[LayerName]) {
-        <V as VisitAll>::visit_layer_names(&mut self.visitor, node);
-        <[LayerName] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
-        <V as VisitAll>::visit_layer_prelude(&mut self.visitor, node);
-        <LayerPrelude as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_length(&mut self, node: &Length) {
-        <V as VisitAll>::visit_length(&mut self.visitor, node);
-        <Length as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_length_percentage(&mut self, node: &LengthPercentage) {
-        <V as VisitAll>::visit_length_percentage(&mut self.visitor, node);
-        <LengthPercentage as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
-        <V as VisitAll>::visit_list_of_component_values(&mut self.visitor, node);
-        <ListOfComponentValues as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_and(&mut self, node: &MediaAnd) {
-        <V as VisitAll>::visit_media_and(&mut self.visitor, node);
-        <MediaAnd as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_condition(&mut self, node: &MediaCondition) {
-        <V as VisitAll>::visit_media_condition(&mut self.visitor, node);
-        <MediaCondition as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
-        <V as VisitAll>::visit_media_condition_all_type(&mut self.visitor, node);
-        <MediaConditionAllType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
-        <V as VisitAll>::visit_media_condition_all_types(&mut self.visitor, node);
-        <[MediaConditionAllType] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
-        <V as VisitAll>::visit_media_condition_type(&mut self.visitor, node);
-        <MediaConditionType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
-        <V as VisitAll>::visit_media_condition_without_or(&mut self.visitor, node);
-        <MediaConditionWithoutOr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_type(&mut self, node: &MediaConditionWithoutOrType) {
-        <V as VisitAll>::visit_media_condition_without_or_type(&mut self.visitor, node);
-        <MediaConditionWithoutOrType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_types(&mut self, node: &[MediaConditionWithoutOrType]) {
-        <V as VisitAll>::visit_media_condition_without_or_types(&mut self.visitor, node);
-        <[MediaConditionWithoutOrType] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature(&mut self, node: &MediaFeature) {
-        <V as VisitAll>::visit_media_feature(&mut self.visitor, node);
-        <MediaFeature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
-        <V as VisitAll>::visit_media_feature_boolean(&mut self.visitor, node);
-        <MediaFeatureBoolean as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
-        <V as VisitAll>::visit_media_feature_name(&mut self.visitor, node);
-        <MediaFeatureName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
-        <V as VisitAll>::visit_media_feature_plain(&mut self.visitor, node);
-        <MediaFeaturePlain as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
-        <V as VisitAll>::visit_media_feature_range(&mut self.visitor, node);
-        <MediaFeatureRange as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
-        <V as VisitAll>::visit_media_feature_range_comparison(&mut self.visitor, node);
-        <MediaFeatureRangeComparison as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
-        <V as VisitAll>::visit_media_feature_range_interval(&mut self.visitor, node);
-        <MediaFeatureRangeInterval as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
-        <V as VisitAll>::visit_media_feature_value(&mut self.visitor, node);
-        <MediaFeatureValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_in_parens(&mut self, node: &MediaInParens) {
-        <V as VisitAll>::visit_media_in_parens(&mut self.visitor, node);
-        <MediaInParens as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_not(&mut self, node: &MediaNot) {
-        <V as VisitAll>::visit_media_not(&mut self.visitor, node);
-        <MediaNot as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_or(&mut self, node: &MediaOr) {
-        <V as VisitAll>::visit_media_or(&mut self.visitor, node);
-        <MediaOr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_query(&mut self, node: &MediaQuery) {
-        <V as VisitAll>::visit_media_query(&mut self.visitor, node);
-        <MediaQuery as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_query_list(&mut self, node: &MediaQueryList) {
-        <V as VisitAll>::visit_media_query_list(&mut self.visitor, node);
-        <MediaQueryList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_querys(&mut self, node: &[MediaQuery]) {
-        <V as VisitAll>::visit_media_querys(&mut self.visitor, node);
-        <[MediaQuery] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_media_type(&mut self, node: &MediaType) {
-        <V as VisitAll>::visit_media_type(&mut self.visitor, node);
-        <MediaType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_named_namespace(&mut self, node: &NamedNamespace) {
-        <V as VisitAll>::visit_named_namespace(&mut self.visitor, node);
-        <NamedNamespace as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut self.visitor, node);
-        <Namespace as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
-        <V as VisitAll>::visit_namespace_prefix(&mut self.visitor, node);
-        <NamespacePrefix as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
-        <V as VisitAll>::visit_namespace_prelude(&mut self.visitor, node);
-        <NamespacePrelude as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
-        <V as VisitAll>::visit_namespace_prelude_uri(&mut self.visitor, node);
-        <NamespacePreludeUri as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_nesting_selector(&mut self, node: &NestingSelector) {
-        <V as VisitAll>::visit_nesting_selector(&mut self.visitor, node);
-        <NestingSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <V as VisitAll>::visit_number(&mut self.visitor, node);
-        <Number as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_number_type(&mut self, node: &NumberType) {
-        <V as VisitAll>::visit_number_type(&mut self.visitor, node);
-        <NumberType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>) {
-        <V as VisitAll>::visit_opt_at_rule_prelude(&mut self.visitor, node);
-        <Option<Box<AtRulePrelude>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut self.visitor, node);
-        <Option<swc_atoms::Atom> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_matcher(&mut self, node: &Option<AttributeSelectorMatcher>) {
-        <V as VisitAll>::visit_opt_attribute_selector_matcher(&mut self.visitor, node);
-        <Option<AttributeSelectorMatcher> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_modifier(&mut self, node: &Option<AttributeSelectorModifier>) {
-        <V as VisitAll>::visit_opt_attribute_selector_modifier(&mut self.visitor, node);
-        <Option<AttributeSelectorModifier> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_value(&mut self, node: &Option<AttributeSelectorValue>) {
-        <V as VisitAll>::visit_opt_attribute_selector_value(&mut self.visitor, node);
-        <Option<AttributeSelectorValue> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
-        <V as VisitAll>::visit_opt_combinator(&mut self.visitor, node);
-        <Option<Combinator> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_container_name(&mut self, node: &Option<ContainerName>) {
-        <V as VisitAll>::visit_opt_container_name(&mut self.visitor, node);
-        <Option<ContainerName> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_forgiving_selector_list(&mut self, node: &Option<ForgivingSelectorList>) {
-        <V as VisitAll>::visit_opt_forgiving_selector_list(&mut self.visitor, node);
-        <Option<ForgivingSelectorList> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_function(&mut self, node: &Option<Box<Function>>) {
-        <V as VisitAll>::visit_opt_function(&mut self.visitor, node);
-        <Option<Box<Function>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <V as VisitAll>::visit_opt_ident(&mut self.visitor, node);
-        <Option<Ident> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>) {
-        <V as VisitAll>::visit_opt_import_conditions(&mut self.visitor, node);
-        <Option<Box<ImportConditions>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>) {
-        <V as VisitAll>::visit_opt_import_layer_name(&mut self.visitor, node);
-        <Option<Box<ImportLayerName>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>) {
-        <V as VisitAll>::visit_opt_important_flag(&mut self.visitor, node);
-        <Option<ImportantFlag> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_media_condition_type(&mut self, node: &Option<Box<MediaConditionType>>) {
-        <V as VisitAll>::visit_opt_media_condition_type(&mut self.visitor, node);
-        <Option<Box<MediaConditionType>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>) {
-        <V as VisitAll>::visit_opt_media_query_list(&mut self.visitor, node);
-        <Option<Box<MediaQueryList>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_media_type(&mut self, node: &Option<MediaType>) {
-        <V as VisitAll>::visit_opt_media_type(&mut self.visitor, node);
-        <Option<MediaType> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut self.visitor, node);
-        <Option<Namespace> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_namespace_prefix(&mut self, node: &Option<NamespacePrefix>) {
-        <V as VisitAll>::visit_opt_namespace_prefix(&mut self.visitor, node);
-        <Option<NamespacePrefix> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_nesting_selector(&mut self, node: &Option<NestingSelector>) {
-        <V as VisitAll>::visit_opt_nesting_selector(&mut self.visitor, node);
-        <Option<NestingSelector> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_number(&mut self, node: &Option<Number>) {
-        <V as VisitAll>::visit_opt_number(&mut self.visitor, node);
-        <Option<Number> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_pseudos(&mut self, node: &Option<Vec<PageSelectorPseudo>>) {
-        <V as VisitAll>::visit_opt_page_selector_pseudos(&mut self.visitor, node);
-        <Option<Vec<PageSelectorPseudo>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_type(&mut self, node: &Option<PageSelectorType>) {
-        <V as VisitAll>::visit_opt_page_selector_type(&mut self.visitor, node);
-        <Option<PageSelectorType> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_class_selector_childrens(
-        &mut self,
-        node: &Option<Vec<PseudoClassSelectorChildren>>,
-    ) {
-        <V as VisitAll>::visit_opt_pseudo_class_selector_childrens(&mut self.visitor, node);
-        <Option<Vec<PseudoClassSelectorChildren>> as VisitWith<Self>>::visit_children_with(
-            node, self,
-        );
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_element_selector_childrens(
-        &mut self,
-        node: &Option<Vec<PseudoElementSelectorChildren>>,
-    ) {
-        <V as VisitAll>::visit_opt_pseudo_element_selector_childrens(&mut self.visitor, node);
-        <Option<Vec<PseudoElementSelectorChildren>> as VisitWith<Self>>::visit_children_with(
-            node, self,
-        );
-    }
-
-    #[inline]
-    fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>) {
-        <V as VisitAll>::visit_opt_simple_block(&mut self.visitor, node);
-        <Option<SimpleBlock> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>) {
-        <V as VisitAll>::visit_opt_type_selector(&mut self.visitor, node);
-        <Option<Box<TypeSelector>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>) {
-        <V as VisitAll>::visit_opt_url_modifiers(&mut self.visitor, node);
-        <Option<Vec<UrlModifier>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_url_value(&mut self, node: &Option<Box<UrlValue>>) {
-        <V as VisitAll>::visit_opt_url_value(&mut self.visitor, node);
-        <Option<Box<UrlValue>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_page_selector(&mut self, node: &PageSelector) {
-        <V as VisitAll>::visit_page_selector(&mut self.visitor, node);
-        <PageSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
-        <V as VisitAll>::visit_page_selector_list(&mut self.visitor, node);
-        <PageSelectorList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
-        <V as VisitAll>::visit_page_selector_pseudo(&mut self.visitor, node);
-        <PageSelectorPseudo as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
-        <V as VisitAll>::visit_page_selector_pseudos(&mut self.visitor, node);
-        <[PageSelectorPseudo] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
-        <V as VisitAll>::visit_page_selector_type(&mut self.visitor, node);
-        <PageSelectorType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_page_selectors(&mut self, node: &[PageSelector]) {
-        <V as VisitAll>::visit_page_selectors(&mut self.visitor, node);
-        <[PageSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_percentage(&mut self, node: &Percentage) {
-        <V as VisitAll>::visit_percentage(&mut self.visitor, node);
-        <Percentage as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
-        <V as VisitAll>::visit_pseudo_class_selector(&mut self.visitor, node);
-        <PseudoClassSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
-        <V as VisitAll>::visit_pseudo_class_selector_children(&mut self.visitor, node);
-        <PseudoClassSelectorChildren as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
-        <V as VisitAll>::visit_pseudo_class_selector_childrens(&mut self.visitor, node);
-        <[PseudoClassSelectorChildren] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
-        <V as VisitAll>::visit_pseudo_element_selector(&mut self.visitor, node);
-        <PseudoElementSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
-        <V as VisitAll>::visit_pseudo_element_selector_children(&mut self.visitor, node);
-        <PseudoElementSelectorChildren as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
-        <V as VisitAll>::visit_pseudo_element_selector_childrens(&mut self.visitor, node);
-        <[PseudoElementSelectorChildren] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
-        <V as VisitAll>::visit_qualified_rule(&mut self.visitor, node);
-        <QualifiedRule as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
-        <V as VisitAll>::visit_qualified_rule_prelude(&mut self.visitor, node);
-        <QualifiedRulePrelude as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_query_in_parens(&mut self, node: &QueryInParens) {
-        <V as VisitAll>::visit_query_in_parens(&mut self.visitor, node);
-        <QueryInParens as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ratio(&mut self, node: &Ratio) {
-        <V as VisitAll>::visit_ratio(&mut self.visitor, node);
-        <Ratio as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_relative_selector(&mut self, node: &RelativeSelector) {
-        <V as VisitAll>::visit_relative_selector(&mut self.visitor, node);
-        <RelativeSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
-        <V as VisitAll>::visit_relative_selector_list(&mut self.visitor, node);
-        <RelativeSelectorList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
-        <V as VisitAll>::visit_relative_selectors(&mut self.visitor, node);
-        <[RelativeSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_resolution(&mut self, node: &Resolution) {
-        <V as VisitAll>::visit_resolution(&mut self.visitor, node);
-        <Resolution as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_rule(&mut self, node: &Rule) {
-        <V as VisitAll>::visit_rule(&mut self.visitor, node);
-        <Rule as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_rules(&mut self, node: &[Rule]) {
-        <V as VisitAll>::visit_rules(&mut self.visitor, node);
-        <[Rule] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_scope_range(&mut self, node: &ScopeRange) {
-        <V as VisitAll>::visit_scope_range(&mut self.visitor, node);
-        <ScopeRange as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_selector_list(&mut self, node: &SelectorList) {
-        <V as VisitAll>::visit_selector_list(&mut self.visitor, node);
-        <SelectorList as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
-        <V as VisitAll>::visit_sequence_of_custom_idents(&mut self.visitor, node);
-        <SequenceOfCustomIdents as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_simple_block(&mut self, node: &SimpleBlock) {
-        <V as VisitAll>::visit_simple_block(&mut self.visitor, node);
-        <SimpleBlock as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature(&mut self, node: &SizeFeature) {
-        <V as VisitAll>::visit_size_feature(&mut self.visitor, node);
-        <SizeFeature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
-        <V as VisitAll>::visit_size_feature_boolean(&mut self.visitor, node);
-        <SizeFeatureBoolean as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
-        <V as VisitAll>::visit_size_feature_name(&mut self.visitor, node);
-        <SizeFeatureName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
-        <V as VisitAll>::visit_size_feature_plain(&mut self.visitor, node);
-        <SizeFeaturePlain as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
-        <V as VisitAll>::visit_size_feature_range(&mut self.visitor, node);
-        <SizeFeatureRange as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
-        <V as VisitAll>::visit_size_feature_range_comparison(&mut self.visitor, node);
-        <SizeFeatureRangeComparison as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
-        <V as VisitAll>::visit_size_feature_range_interval(&mut self.visitor, node);
-        <SizeFeatureRangeInterval as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
-        <V as VisitAll>::visit_size_feature_value(&mut self.visitor, node);
-        <SizeFeatureValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut self.visitor, node);
-        <swc_common::Span as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <V as VisitAll>::visit_str(&mut self.visitor, node);
-        <Str as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_style_block(&mut self, node: &StyleBlock) {
-        <V as VisitAll>::visit_style_block(&mut self.visitor, node);
-        <StyleBlock as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_stylesheet(&mut self, node: &Stylesheet) {
-        <V as VisitAll>::visit_stylesheet(&mut self.visitor, node);
-        <Stylesheet as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
-        <V as VisitAll>::visit_subclass_selector(&mut self.visitor, node);
-        <SubclassSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
-        <V as VisitAll>::visit_subclass_selectors(&mut self.visitor, node);
-        <[SubclassSelector] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_and(&mut self, node: &SupportsAnd) {
-        <V as VisitAll>::visit_supports_and(&mut self.visitor, node);
-        <SupportsAnd as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_condition(&mut self, node: &SupportsCondition) {
-        <V as VisitAll>::visit_supports_condition(&mut self.visitor, node);
-        <SupportsCondition as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
-        <V as VisitAll>::visit_supports_condition_type(&mut self.visitor, node);
-        <SupportsConditionType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
-        <V as VisitAll>::visit_supports_condition_types(&mut self.visitor, node);
-        <[SupportsConditionType] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_feature(&mut self, node: &SupportsFeature) {
-        <V as VisitAll>::visit_supports_feature(&mut self.visitor, node);
-        <SupportsFeature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
-        <V as VisitAll>::visit_supports_in_parens(&mut self.visitor, node);
-        <SupportsInParens as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_not(&mut self, node: &SupportsNot) {
-        <V as VisitAll>::visit_supports_not(&mut self.visitor, node);
-        <SupportsNot as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_supports_or(&mut self, node: &SupportsOr) {
-        <V as VisitAll>::visit_supports_or(&mut self.visitor, node);
-        <SupportsOr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
-        <V as VisitAll>::visit_tag_name_selector(&mut self.visitor, node);
-        <TagNameSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_time(&mut self, node: &Time) {
-        <V as VisitAll>::visit_time(&mut self.visitor, node);
-        <Time as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_time_percentage(&mut self, node: &TimePercentage) {
-        <V as VisitAll>::visit_time_percentage(&mut self.visitor, node);
-        <TimePercentage as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut self.visitor, node);
-        <Token as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut self.visitor, node);
-        <TokenAndSpan as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_type_selector(&mut self, node: &TypeSelector) {
-        <V as VisitAll>::visit_type_selector(&mut self.visitor, node);
-        <TypeSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_unicode_range(&mut self, node: &UnicodeRange) {
-        <V as VisitAll>::visit_unicode_range(&mut self.visitor, node);
-        <UnicodeRange as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_universal_selector(&mut self, node: &UniversalSelector) {
-        <V as VisitAll>::visit_universal_selector(&mut self.visitor, node);
-        <UniversalSelector as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
-        <V as VisitAll>::visit_unknown_dimension(&mut self.visitor, node);
-        <UnknownDimension as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_url(&mut self, node: &Url) {
-        <V as VisitAll>::visit_url(&mut self.visitor, node);
-        <Url as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
-        <V as VisitAll>::visit_url_key_value(&mut self.visitor, node);
-        <UrlKeyValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_url_modifier(&mut self, node: &UrlModifier) {
-        <V as VisitAll>::visit_url_modifier(&mut self.visitor, node);
-        <UrlModifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
-        <V as VisitAll>::visit_url_modifiers(&mut self.visitor, node);
-        <[UrlModifier] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_url_value(&mut self, node: &UrlValue) {
-        <V as VisitAll>::visit_url_value(&mut self.visitor, node);
-        <UrlValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
-        <V as VisitAll>::visit_url_value_raw(&mut self.visitor, node);
-        <UrlValueRaw as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_wq_name(&mut self, node: &WqName) {
-        <V as VisitAll>::visit_wq_name(&mut self.visitor, node);
-        <WqName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-}
-#[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitWith<V: ?Sized + Visit> {
-    #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with(&self, visitor: &mut V);
-    #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with(&self, visitor: &mut V);
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AbsoluteColorBase {
-    #[doc = "Calls [Visit`::visit_absolute_color_base`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_absolute_color_base(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AbsoluteColorBase::HexColor { 0: _field_0 } => {
-                <HexColor as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AbsoluteColorBase::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AlphaValue {
-    #[doc = "Calls [Visit`::visit_alpha_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_alpha_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AlphaValue::Number { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AlphaValue::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AnPlusB {
-    #[doc = "Calls [Visit`::visit_an_plus_b`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_an_plus_b(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AnPlusB::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AnPlusB::AnPlusBNotation { 0: _field_0 } => {
-                <AnPlusBNotation as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AnPlusBNotation {
-    #[doc = "Calls [Visit`::visit_an_plus_b_notation`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_an_plus_b_notation(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AnPlusBNotation {
-                span,
-                a,
-                a_raw,
-                b,
-                b_raw,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(a_raw, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(b_raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Angle {
-    #[doc = "Calls [Visit`::visit_angle`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_angle(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Angle { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AnglePercentage {
-    #[doc = "Calls [Visit`::visit_angle_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_angle_percentage(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AnglePercentage::Angle { 0: _field_0 } => {
-                <Angle as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AnglePercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AnyNamespace {
-    #[doc = "Calls [Visit`::visit_any_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_any_namespace(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AnyNamespace { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AtRule {
-    #[doc = "Calls [Visit`::visit_at_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_at_rule(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AtRule {
-                span,
-                name,
-                prelude,
-                block,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <AtRuleName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<Box<AtRulePrelude>> as VisitWith<V>>::visit_with(prelude, visitor)
-                };
-                {
-                    <Option<SimpleBlock> as VisitWith<V>>::visit_with(block, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AtRuleName {
-    #[doc = "Calls [Visit`::visit_at_rule_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_at_rule_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AtRuleName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRuleName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AtRulePrelude {
-    #[doc = "Calls [Visit`::visit_at_rule_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_at_rule_prelude(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AtRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::CharsetPrelude { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::PropertyPrelude { 0: _field_0 } => {
-                <CustomPropertyName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::CounterStylePrelude { 0: _field_0 } => {
-                <CustomIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::ColorProfilePrelude { 0: _field_0 } => {
-                <ColorProfileName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::DocumentPrelude { 0: _field_0 } => {
-                <DocumentPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 } => {
-                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 } => {
-                <FontFeatureValuesPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::NestPrelude { 0: _field_0 } => {
-                <SelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::KeyframesPrelude { 0: _field_0 } => {
-                <KeyframesName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::ImportPrelude { 0: _field_0 } => {
-                <ImportPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::NamespacePrelude { 0: _field_0 } => {
-                <NamespacePrelude as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::MediaPrelude { 0: _field_0 } => {
-                <MediaQueryList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::SupportsPrelude { 0: _field_0 } => {
-                <SupportsCondition as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::PagePrelude { 0: _field_0 } => {
-                <PageSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::LayerPrelude { 0: _field_0 } => {
-                <LayerPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
-                <ContainerCondition as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::CustomMediaPrelude { 0: _field_0 } => {
-                <CustomMediaQuery as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AtRulePrelude::ScopePrelude { 0: _field_0 } => {
-                <ScopeRange as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelector {
-    #[doc = "Calls [Visit`::visit_attribute_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_attribute_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AttributeSelector {
-                span,
-                name,
-                matcher,
-                value,
-                modifier,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <WqName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<AttributeSelectorMatcher> as VisitWith<V>>::visit_with(matcher, visitor)
-                };
-                {
-                    <Option<AttributeSelectorValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<AttributeSelectorModifier> as VisitWith<V>>::visit_with(
-                        modifier, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorMatcher {
-    #[doc = "Calls [Visit`::visit_attribute_selector_matcher`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_attribute_selector_matcher(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AttributeSelectorMatcher { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <AttributeSelectorMatcherValue as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorMatcherValue {
-    #[doc = "Calls [Visit`::visit_attribute_selector_matcher_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_attribute_selector_matcher_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AttributeSelectorMatcherValue::Equals => {}
-            AttributeSelectorMatcherValue::Tilde => {}
-            AttributeSelectorMatcherValue::Bar => {}
-            AttributeSelectorMatcherValue::Caret => {}
-            AttributeSelectorMatcherValue::Dollar => {}
-            AttributeSelectorMatcherValue::Asterisk => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorModifier {
-    #[doc = "Calls [Visit`::visit_attribute_selector_modifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_attribute_selector_modifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AttributeSelectorModifier { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorValue {
-    #[doc = "Calls [Visit`::visit_attribute_selector_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_attribute_selector_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AttributeSelectorValue::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AttributeSelectorValue::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BinOp {
-    #[doc = "Calls [Visit`::visit_bin_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_bin_op(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BinOp::Add => {}
-            BinOp::Sub => {}
-            BinOp::Mul => {}
-            BinOp::Div => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CalcOperator {
-    #[doc = "Calls [Visit`::visit_calc_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_operator(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CalcOperator { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <CalcOperatorType as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CalcOperatorType {
-    #[doc = "Calls [Visit`::visit_calc_operator_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_operator_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CalcOperatorType::Add => {}
-            CalcOperatorType::Sub => {}
-            CalcOperatorType::Mul => {}
-            CalcOperatorType::Div => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CalcProduct {
-    #[doc = "Calls [Visit`::visit_calc_product`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_product(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CalcProduct { span, expressions } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<CalcValueOrOperator> as VisitWith<V>>::visit_with(expressions, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CalcProductOrOperator {
-    #[doc = "Calls [Visit`::visit_calc_product_or_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_product_or_operator(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CalcProductOrOperator::Product { 0: _field_0 } => {
-                <CalcProduct as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CalcProductOrOperator::Operator { 0: _field_0 } => {
-                <CalcOperator as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CalcSum {
-    #[doc = "Calls [Visit`::visit_calc_sum`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_sum(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CalcSum { span, expressions } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<CalcProductOrOperator> as VisitWith<V>>::visit_with(expressions, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CalcValue {
-    #[doc = "Calls [Visit`::visit_calc_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CalcValue::Number { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CalcValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CalcValue::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CalcValue::Constant { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CalcValue::Sum { 0: _field_0 } => {
-                <CalcSum as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CalcValue::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CalcValueOrOperator {
-    #[doc = "Calls [Visit`::visit_calc_value_or_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_value_or_operator(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CalcValueOrOperator::Value { 0: _field_0 } => {
-                <CalcValue as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CalcValueOrOperator::Operator { 0: _field_0 } => {
-                <CalcOperator as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ClassSelector {
-    #[doc = "Calls [Visit`::visit_class_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ClassSelector { span, text } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(text, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CmykComponent {
-    #[doc = "Calls [Visit`::visit_cmyk_component`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_cmyk_component(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CmykComponent::Number { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CmykComponent::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CmykComponent::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Color {
-    #[doc = "Calls [Visit`::visit_color`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_color(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Color::AbsoluteColorBase { 0: _field_0 } => {
-                <AbsoluteColorBase as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Color::CurrentColorOrSystemColor { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Color::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ColorProfileName {
-    #[doc = "Calls [Visit`::visit_color_profile_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_color_profile_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ColorProfileName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ColorProfileName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Combinator {
-    #[doc = "Calls [Visit`::visit_combinator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_combinator(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Combinator { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <CombinatorValue as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CombinatorValue {
-    #[doc = "Calls [Visit`::visit_combinator_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_combinator_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CombinatorValue::Descendant => {}
-            CombinatorValue::NextSibling => {}
-            CombinatorValue::Child => {}
-            CombinatorValue::LaterSibling => {}
-            CombinatorValue::Column => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ComplexSelector {
-    #[doc = "Calls [Visit`::visit_complex_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_complex_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ComplexSelector { span, children } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ComplexSelectorChildren> as VisitWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ComplexSelectorChildren {
-    #[doc = "Calls [Visit`::visit_complex_selector_children`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_complex_selector_children(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ComplexSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComplexSelectorChildren::Combinator { 0: _field_0 } => {
-                <Combinator as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ComponentValue {
-    #[doc = "Calls [Visit`::visit_component_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_component_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ComponentValue::PreservedToken { 0: _field_0 } => {
-                <Box<TokenAndSpan> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Function { 0: _field_0 } => {
-                <Box<Function> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::SimpleBlock { 0: _field_0 } => {
-                <Box<SimpleBlock> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::KeyframeBlock { 0: _field_0 } => {
-                <Box<KeyframeBlock> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Ident { 0: _field_0 } => {
-                <Box<Ident> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::DashedIdent { 0: _field_0 } => {
-                <Box<DashedIdent> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Str { 0: _field_0 } => {
-                <Box<Str> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Url { 0: _field_0 } => {
-                <Box<Url> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Integer { 0: _field_0 } => {
-                <Box<Integer> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Number { 0: _field_0 } => {
-                <Box<Number> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Percentage { 0: _field_0 } => {
-                <Box<Percentage> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Dimension { 0: _field_0 } => {
-                <Box<Dimension> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::LengthPercentage { 0: _field_0 } => {
-                <Box<LengthPercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::FrequencyPercentage { 0: _field_0 } => {
-                <Box<FrequencyPercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::AnglePercentage { 0: _field_0 } => {
-                <Box<AnglePercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::TimePercentage { 0: _field_0 } => {
-                <Box<TimePercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Ratio { 0: _field_0 } => {
-                <Box<Ratio> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::UnicodeRange { 0: _field_0 } => {
-                <Box<UnicodeRange> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Color { 0: _field_0 } => {
-                <Box<Color> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::AlphaValue { 0: _field_0 } => {
-                <Box<AlphaValue> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Hue { 0: _field_0 } => {
-                <Box<Hue> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::CmykComponent { 0: _field_0 } => {
-                <Box<CmykComponent> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Delimiter { 0: _field_0 } => {
-                <Box<Delimiter> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::CalcSum { 0: _field_0 } => {
-                <Box<CalcSum> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::ComplexSelector { 0: _field_0 } => {
-                <Box<ComplexSelector> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::LayerName { 0: _field_0 } => {
-                <Box<LayerName> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::SupportsCondition { 0: _field_0 } => {
-                <Box<SupportsCondition> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ComponentValue::IdSelector { 0: _field_0 } => {
-                <Box<IdSelector> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CompoundSelector {
-    #[doc = "Calls [Visit`::visit_compound_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_compound_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CompoundSelector {
-                span,
-                nesting_selector,
-                type_selector,
-                subclass_selectors,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<NestingSelector> as VisitWith<V>>::visit_with(nesting_selector, visitor)
-                };
-                {
-                    <Option<Box<TypeSelector>> as VisitWith<V>>::visit_with(type_selector, visitor)
-                };
-                {
-                    <Vec<SubclassSelector> as VisitWith<V>>::visit_with(subclass_selectors, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CompoundSelectorList {
-    #[doc = "Calls [Visit`::visit_compound_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_compound_selector_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CompoundSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<CompoundSelector> as VisitWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContainerCondition {
-    #[doc = "Calls [Visit`::visit_container_condition`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_condition(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContainerCondition { span, name, query } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<ContainerName> as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <ContainerQuery as VisitWith<V>>::visit_with(query, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContainerName {
-    #[doc = "Calls [Visit`::visit_container_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContainerName::CustomIdent { 0: _field_0 } => {
-                <CustomIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContainerQuery {
-    #[doc = "Calls [Visit`::visit_container_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_query(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContainerQuery { span, queries } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ContainerQueryType> as VisitWith<V>>::visit_with(queries, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryAnd {
-    #[doc = "Calls [Visit`::visit_container_query_and`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_query_and(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContainerQueryAnd {
-                span,
-                keyword,
-                query,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <QueryInParens as VisitWith<V>>::visit_with(query, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryNot {
-    #[doc = "Calls [Visit`::visit_container_query_not`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_query_not(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContainerQueryNot {
-                span,
-                keyword,
-                query,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <QueryInParens as VisitWith<V>>::visit_with(query, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryOr {
-    #[doc = "Calls [Visit`::visit_container_query_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_query_or(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContainerQueryOr {
-                span,
-                keyword,
-                query,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <QueryInParens as VisitWith<V>>::visit_with(query, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryType {
-    #[doc = "Calls [Visit`::visit_container_query_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_query_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContainerQueryType::Not { 0: _field_0 } => {
-                <ContainerQueryNot as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ContainerQueryType::And { 0: _field_0 } => {
-                <ContainerQueryAnd as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ContainerQueryType::Or { 0: _field_0 } => {
-                <ContainerQueryOr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ContainerQueryType::QueryInParens { 0: _field_0 } => {
-                <QueryInParens as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CustomHighlightName {
-    #[doc = "Calls [Visit`::visit_custom_highlight_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_custom_highlight_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CustomHighlightName { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CustomIdent {
-    #[doc = "Calls [Visit`::visit_custom_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_custom_ident(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CustomIdent { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CustomMediaQuery {
-    #[doc = "Calls [Visit`::visit_custom_media_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_custom_media_query(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CustomMediaQuery { span, name, media } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <ExtensionName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <CustomMediaQueryMediaType as VisitWith<V>>::visit_with(media, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CustomMediaQueryMediaType {
-    #[doc = "Calls [Visit`::visit_custom_media_query_media_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_custom_media_query_media_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CustomMediaQueryMediaType::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 } => {
-                <MediaQueryList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CustomPropertyName {
-    #[doc = "Calls [Visit`::visit_custom_property_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_custom_property_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CustomPropertyName { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DashedIdent {
-    #[doc = "Calls [Visit`::visit_dashed_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_dashed_ident(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DashedIdent { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Declaration {
-    #[doc = "Calls [Visit`::visit_declaration`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_declaration(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Declaration {
-                span,
-                name,
-                value,
-                important,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <DeclarationName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<ImportantFlag> as VisitWith<V>>::visit_with(important, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DeclarationName {
-    #[doc = "Calls [Visit`::visit_declaration_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_declaration_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DeclarationName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            DeclarationName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DeclarationOrAtRule {
-    #[doc = "Calls [Visit`::visit_declaration_or_at_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_declaration_or_at_rule(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DeclarationOrAtRule::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            DeclarationOrAtRule::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Delimiter {
-    #[doc = "Calls [Visit`::visit_delimiter`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_delimiter(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Delimiter { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <DelimiterValue as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DelimiterValue {
-    #[doc = "Calls [Visit`::visit_delimiter_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_delimiter_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DelimiterValue::Comma => {}
-            DelimiterValue::Solidus => {}
-            DelimiterValue::Semicolon => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Dimension {
-    #[doc = "Calls [Visit`::visit_dimension`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_dimension(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Dimension::Length { 0: _field_0 } => {
-                <Length as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Dimension::Angle { 0: _field_0 } => {
-                <Angle as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Dimension::Time { 0: _field_0 } => {
-                <Time as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Dimension::Frequency { 0: _field_0 } => {
-                <Frequency as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Dimension::Resolution { 0: _field_0 } => {
-                <Resolution as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Dimension::Flex { 0: _field_0 } => {
-                <Flex as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Dimension::UnknownDimension { 0: _field_0 } => {
-                <UnknownDimension as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DimensionToken {
-    #[doc = "Calls [Visit`::visit_dimension_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_dimension_token(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DimensionToken {
-                value,
-                raw_value,
-                unit,
-                type_flag,
-                raw_unit,
-            } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw_value, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(unit, visitor)
-                };
-                {
-                    <NumberType as VisitWith<V>>::visit_with(type_flag, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw_unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DocumentPrelude {
-    #[doc = "Calls [Visit`::visit_document_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_document_prelude(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DocumentPrelude {
-                span,
-                matching_functions,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<DocumentPreludeMatchingFunction> as VisitWith<V>>::visit_with(
-                        matching_functions,
-                        visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DocumentPreludeMatchingFunction {
-    #[doc = "Calls [Visit`::visit_document_prelude_matching_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_document_prelude_matching_function(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DocumentPreludeMatchingFunction::Url { 0: _field_0 } => {
-                <Url as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            DocumentPreludeMatchingFunction::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExtensionName {
-    #[doc = "Calls [Visit`::visit_extension_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_extension_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExtensionName { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for FamilyName {
-    #[doc = "Calls [Visit`::visit_family_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_family_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            FamilyName::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            FamilyName::SequenceOfCustomIdents { 0: _field_0 } => {
-                <SequenceOfCustomIdents as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Flex {
-    #[doc = "Calls [Visit`::visit_flex`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_flex(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Flex { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for FontFeatureValuesPrelude {
-    #[doc = "Calls [Visit`::visit_font_feature_values_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_font_feature_values_prelude(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            FontFeatureValuesPrelude { span, font_family } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<FamilyName> as VisitWith<V>>::visit_with(font_family, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForgivingComplexSelector {
-    #[doc = "Calls [Visit`::visit_forgiving_complex_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_forgiving_complex_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForgivingComplexSelector::ComplexSelector { 0: _field_0 } => {
-                <ComplexSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForgivingRelativeSelector {
-    #[doc = "Calls [Visit`::visit_forgiving_relative_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_forgiving_relative_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForgivingRelativeSelector::RelativeSelector { 0: _field_0 } => {
-                <RelativeSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForgivingRelativeSelectorList {
-    #[doc = "Calls [Visit`::visit_forgiving_relative_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_forgiving_relative_selector_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForgivingRelativeSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ForgivingRelativeSelector> as VisitWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForgivingSelectorList {
-    #[doc = "Calls [Visit`::visit_forgiving_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_forgiving_selector_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForgivingSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ForgivingComplexSelector> as VisitWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Frequency {
-    #[doc = "Calls [Visit`::visit_frequency`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_frequency(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Frequency { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for FrequencyPercentage {
-    #[doc = "Calls [Visit`::visit_frequency_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_frequency_percentage(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            FrequencyPercentage::Frequency { 0: _field_0 } => {
-                <Frequency as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            FrequencyPercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Function {
-    #[doc = "Calls [Visit`::visit_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_function(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Function { span, name, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <FunctionName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for FunctionName {
-    #[doc = "Calls [Visit`::visit_function_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_function_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            FunctionName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            FunctionName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for GeneralEnclosed {
-    #[doc = "Calls [Visit`::visit_general_enclosed`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_general_enclosed(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            GeneralEnclosed::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            GeneralEnclosed::SimpleBlock { 0: _field_0 } => {
-                <SimpleBlock as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for HexColor {
-    #[doc = "Calls [Visit`::visit_hex_color`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_hex_color(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            HexColor { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Hue {
-    #[doc = "Calls [Visit`::visit_hue`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_hue(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Hue::Number { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Hue::Angle { 0: _field_0 } => {
-                <Angle as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for IdSelector {
-    #[doc = "Calls [Visit`::visit_id_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_id_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            IdSelector { span, text } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(text, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Ident {
-    #[doc = "Calls [Visit`::visit_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ident(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Ident { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportConditions {
-    #[doc = "Calls [Visit`::visit_import_conditions`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_conditions(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportConditions {
-                span,
-                supports,
-                media,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Box<Function>> as VisitWith<V>>::visit_with(supports, visitor)
-                };
-                {
-                    <Option<Box<MediaQueryList>> as VisitWith<V>>::visit_with(media, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportHref {
-    #[doc = "Calls [Visit`::visit_import_href`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_href(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportHref::Url { 0: _field_0 } => {
-                <Url as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ImportHref::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportLayerName {
-    #[doc = "Calls [Visit`::visit_import_layer_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_layer_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportLayerName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ImportLayerName::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportPrelude {
-    #[doc = "Calls [Visit`::visit_import_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_prelude(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportPrelude {
-                span,
-                href,
-                layer_name,
-                import_conditions,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<ImportHref> as VisitWith<V>>::visit_with(href, visitor)
-                };
-                {
-                    <Option<Box<ImportLayerName>> as VisitWith<V>>::visit_with(layer_name, visitor)
-                };
-                {
-                    <Option<Box<ImportConditions>> as VisitWith<V>>::visit_with(
-                        import_conditions,
-                        visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportantFlag {
-    #[doc = "Calls [Visit`::visit_important_flag`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_important_flag(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportantFlag { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Integer {
-    #[doc = "Calls [Visit`::visit_integer`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_integer(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Integer { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for KeyframeBlock {
-    #[doc = "Calls [Visit`::visit_keyframe_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_keyframe_block(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            KeyframeBlock {
-                span,
-                prelude,
-                block,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<KeyframeSelector> as VisitWith<V>>::visit_with(prelude, visitor)
-                };
-                {
-                    <SimpleBlock as VisitWith<V>>::visit_with(block, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for KeyframeSelector {
-    #[doc = "Calls [Visit`::visit_keyframe_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_keyframe_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            KeyframeSelector::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            KeyframeSelector::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for KeyframesName {
-    #[doc = "Calls [Visit`::visit_keyframes_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_keyframes_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            KeyframesName::CustomIdent { 0: _field_0 } => {
-                <Box<CustomIdent> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            KeyframesName::Str { 0: _field_0 } => {
-                <Box<Str> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            KeyframesName::PseudoPrefix { 0: _field_0 } => {
-                <Box<KeyframesPseudoPrefix> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            KeyframesName::PseudoFunction { 0: _field_0 } => {
-                <Box<KeyframesPseudoFunction> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for KeyframesPseudoFunction {
-    #[doc = "Calls [Visit`::visit_keyframes_pseudo_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_keyframes_pseudo_function(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            KeyframesPseudoFunction { span, pseudo, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(pseudo, visitor)
-                };
-                {
-                    <KeyframesName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for KeyframesPseudoPrefix {
-    #[doc = "Calls [Visit`::visit_keyframes_pseudo_prefix`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_keyframes_pseudo_prefix(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            KeyframesPseudoPrefix { span, pseudo, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(pseudo, visitor)
-                };
-                {
-                    <KeyframesName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for LayerName {
-    #[doc = "Calls [Visit`::visit_layer_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_layer_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            LayerName { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Ident> as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for LayerNameList {
-    #[doc = "Calls [Visit`::visit_layer_name_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_layer_name_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            LayerNameList { span, name_list } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<LayerName> as VisitWith<V>>::visit_with(name_list, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for LayerPrelude {
-    #[doc = "Calls [Visit`::visit_layer_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_layer_prelude(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            LayerPrelude::Name { 0: _field_0 } => {
-                <LayerName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            LayerPrelude::NameList { 0: _field_0 } => {
-                <LayerNameList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Length {
-    #[doc = "Calls [Visit`::visit_length`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_length(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Length { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for LengthPercentage {
-    #[doc = "Calls [Visit`::visit_length_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_length_percentage(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            LengthPercentage::Length { 0: _field_0 } => {
-                <Length as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            LengthPercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ListOfComponentValues {
-    #[doc = "Calls [Visit`::visit_list_of_component_values`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_list_of_component_values(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ListOfComponentValues { span, children } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaAnd {
-    #[doc = "Calls [Visit`::visit_media_and`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_and(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaAnd {
-                span,
-                keyword,
-                condition,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <MediaInParens as VisitWith<V>>::visit_with(condition, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaCondition {
-    #[doc = "Calls [Visit`::visit_media_condition`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_condition(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaCondition { span, conditions } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<MediaConditionAllType> as VisitWith<V>>::visit_with(conditions, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionAllType {
-    #[doc = "Calls [Visit`::visit_media_condition_all_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_condition_all_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaConditionAllType::Not { 0: _field_0 } => {
-                <MediaNot as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaConditionAllType::And { 0: _field_0 } => {
-                <MediaAnd as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaConditionAllType::Or { 0: _field_0 } => {
-                <MediaOr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaConditionAllType::MediaInParens { 0: _field_0 } => {
-                <MediaInParens as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionType {
-    #[doc = "Calls [Visit`::visit_media_condition_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_condition_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaConditionType::All { 0: _field_0 } => {
-                <MediaCondition as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaConditionType::WithoutOr { 0: _field_0 } => {
-                <MediaConditionWithoutOr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionWithoutOr {
-    #[doc = "Calls [Visit`::visit_media_condition_without_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_condition_without_or(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaConditionWithoutOr { span, conditions } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<MediaConditionWithoutOrType> as VisitWith<V>>::visit_with(
-                        conditions, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionWithoutOrType {
-    #[doc = "Calls [Visit`::visit_media_condition_without_or_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_condition_without_or_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaConditionWithoutOrType::Not { 0: _field_0 } => {
-                <MediaNot as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaConditionWithoutOrType::And { 0: _field_0 } => {
-                <MediaAnd as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaConditionWithoutOrType::MediaInParens { 0: _field_0 } => {
-                <MediaInParens as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeature {
-    #[doc = "Calls [Visit`::visit_media_feature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeature::Plain { 0: _field_0 } => {
-                <MediaFeaturePlain as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeature::Boolean { 0: _field_0 } => {
-                <MediaFeatureBoolean as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeature::Range { 0: _field_0 } => {
-                <MediaFeatureRange as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeature::RangeInterval { 0: _field_0 } => {
-                <MediaFeatureRangeInterval as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureBoolean {
-    #[doc = "Calls [Visit`::visit_media_feature_boolean`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature_boolean(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeatureBoolean { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <MediaFeatureName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureName {
-    #[doc = "Calls [Visit`::visit_media_feature_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeatureName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeatureName::ExtensionName { 0: _field_0 } => {
-                <ExtensionName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeaturePlain {
-    #[doc = "Calls [Visit`::visit_media_feature_plain`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature_plain(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeaturePlain { span, name, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <MediaFeatureName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureRange {
-    #[doc = "Calls [Visit`::visit_media_feature_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature_range(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeatureRange {
-                span,
-                left,
-                comparison,
-                right,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <MediaFeatureRangeComparison as VisitWith<V>>::visit_with(comparison, visitor)
-                };
-                {
-                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureRangeComparison {
-    #[doc = "Calls [Visit`::visit_media_feature_range_comparison`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature_range_comparison(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeatureRangeComparison::Lt => {}
-            MediaFeatureRangeComparison::Le => {}
-            MediaFeatureRangeComparison::Gt => {}
-            MediaFeatureRangeComparison::Ge => {}
-            MediaFeatureRangeComparison::Eq => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureRangeInterval {
-    #[doc = "Calls [Visit`::visit_media_feature_range_interval`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature_range_interval(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeatureRangeInterval {
-                span,
-                left,
-                left_comparison,
-                name,
-                right_comparison,
-                right,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <MediaFeatureRangeComparison as VisitWith<V>>::visit_with(
-                        left_comparison,
-                        visitor,
-                    )
-                };
-                {
-                    <MediaFeatureName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <MediaFeatureRangeComparison as VisitWith<V>>::visit_with(
-                        right_comparison,
-                        visitor,
-                    )
-                };
-                {
-                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureValue {
-    #[doc = "Calls [Visit`::visit_media_feature_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_feature_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaFeatureValue::Number { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeatureValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeatureValue::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeatureValue::Ratio { 0: _field_0 } => {
-                <Ratio as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaFeatureValue::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaInParens {
-    #[doc = "Calls [Visit`::visit_media_in_parens`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_in_parens(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaInParens::MediaCondition { 0: _field_0 } => {
-                <MediaCondition as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaInParens::Feature { 0: _field_0 } => {
-                <Box<MediaFeature> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MediaInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaNot {
-    #[doc = "Calls [Visit`::visit_media_not`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_not(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaNot {
-                span,
-                keyword,
-                condition,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <MediaInParens as VisitWith<V>>::visit_with(condition, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaOr {
-    #[doc = "Calls [Visit`::visit_media_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_or(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaOr {
-                span,
-                keyword,
-                condition,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <MediaInParens as VisitWith<V>>::visit_with(condition, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaQuery {
-    #[doc = "Calls [Visit`::visit_media_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_query(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaQuery {
-                span,
-                modifier,
-                media_type,
-                keyword,
-                condition,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(modifier, visitor)
-                };
-                {
-                    <Option<MediaType> as VisitWith<V>>::visit_with(media_type, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <Option<Box<MediaConditionType>> as VisitWith<V>>::visit_with(
-                        condition, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaQueryList {
-    #[doc = "Calls [Visit`::visit_media_query_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_query_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaQueryList { span, queries } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<MediaQuery> as VisitWith<V>>::visit_with(queries, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MediaType {
-    #[doc = "Calls [Visit`::visit_media_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MediaType::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NamedNamespace {
-    #[doc = "Calls [Visit`::visit_named_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_named_namespace(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NamedNamespace { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Namespace {
-    #[doc = "Calls [Visit`::visit_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_namespace(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Namespace::Named { 0: _field_0 } => {
-                <NamedNamespace as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Namespace::Any { 0: _field_0 } => {
-                <AnyNamespace as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NamespacePrefix {
-    #[doc = "Calls [Visit`::visit_namespace_prefix`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_namespace_prefix(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NamespacePrefix { span, namespace } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Namespace> as VisitWith<V>>::visit_with(namespace, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NamespacePrelude {
-    #[doc = "Calls [Visit`::visit_namespace_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_namespace_prelude(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NamespacePrelude { span, prefix, uri } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(prefix, visitor)
-                };
-                {
-                    <Box<NamespacePreludeUri> as VisitWith<V>>::visit_with(uri, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NamespacePreludeUri {
-    #[doc = "Calls [Visit`::visit_namespace_prelude_uri`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_namespace_prelude_uri(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NamespacePreludeUri::Url { 0: _field_0 } => {
-                <Url as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            NamespacePreludeUri::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NestingSelector {
-    #[doc = "Calls [Visit`::visit_nesting_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_nesting_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NestingSelector { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Number {
-    #[doc = "Calls [Visit`::visit_number`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_number(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Number { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NumberType {
-    #[doc = "Calls [Visit`::visit_number_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_number_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NumberType::Integer => {}
-            NumberType::Number => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PageSelector {
-    #[doc = "Calls [Visit`::visit_page_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_page_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PageSelector {
-                span,
-                page_type,
-                pseudos,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<PageSelectorType> as VisitWith<V>>::visit_with(page_type, visitor)
-                };
-                {
-                    <Option<Vec<PageSelectorPseudo>> as VisitWith<V>>::visit_with(pseudos, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PageSelectorList {
-    #[doc = "Calls [Visit`::visit_page_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_page_selector_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PageSelectorList { span, selectors } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<PageSelector> as VisitWith<V>>::visit_with(selectors, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PageSelectorPseudo {
-    #[doc = "Calls [Visit`::visit_page_selector_pseudo`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_page_selector_pseudo(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PageSelectorPseudo { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PageSelectorType {
-    #[doc = "Calls [Visit`::visit_page_selector_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_page_selector_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PageSelectorType { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Percentage {
-    #[doc = "Calls [Visit`::visit_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_percentage(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Percentage { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PseudoClassSelector {
-    #[doc = "Calls [Visit`::visit_pseudo_class_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pseudo_class_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PseudoClassSelector {
-                span,
-                name,
-                children,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<Vec<PseudoClassSelectorChildren>> as VisitWith<V>>::visit_with(
-                        children, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PseudoClassSelectorChildren {
-    #[doc = "Calls [Visit`::visit_pseudo_class_selector_children`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pseudo_class_selector_children(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PseudoClassSelectorChildren::PreservedToken { 0: _field_0 } => {
-                <TokenAndSpan as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::AnPlusB { 0: _field_0 } => {
-                <AnPlusB as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
-                <Delimiter as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
-                <ComplexSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::SelectorList { 0: _field_0 } => {
-                <SelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 } => {
-                <ForgivingSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 } => {
-                <CompoundSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 } => {
-                <RelativeSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 } => {
-                <ForgivingRelativeSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PseudoElementSelector {
-    #[doc = "Calls [Visit`::visit_pseudo_element_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pseudo_element_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PseudoElementSelector {
-                span,
-                name,
-                children,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<Vec<PseudoElementSelectorChildren>> as VisitWith<V>>::visit_with(
-                        children, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PseudoElementSelectorChildren {
-    #[doc = "Calls [Visit`::visit_pseudo_element_selector_children`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pseudo_element_selector_children(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PseudoElementSelectorChildren::PreservedToken { 0: _field_0 } => {
-                <TokenAndSpan as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 } => {
-                <CustomHighlightName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for QualifiedRule {
-    #[doc = "Calls [Visit`::visit_qualified_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_qualified_rule(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            QualifiedRule {
-                span,
-                prelude,
-                block,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <QualifiedRulePrelude as VisitWith<V>>::visit_with(prelude, visitor)
-                };
-                {
-                    <SimpleBlock as VisitWith<V>>::visit_with(block, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for QualifiedRulePrelude {
-    #[doc = "Calls [Visit`::visit_qualified_rule_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_qualified_rule_prelude(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            QualifiedRulePrelude::SelectorList { 0: _field_0 } => {
-                <SelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 } => {
-                <RelativeSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for QueryInParens {
-    #[doc = "Calls [Visit`::visit_query_in_parens`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_query_in_parens(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            QueryInParens::ContainerQuery { 0: _field_0 } => {
-                <Box<ContainerQuery> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            QueryInParens::SizeFeature { 0: _field_0 } => {
-                <SizeFeature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            QueryInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Ratio {
-    #[doc = "Calls [Visit`::visit_ratio`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ratio(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Ratio { span, left, right } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <Option<Number> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for RelativeSelector {
-    #[doc = "Calls [Visit`::visit_relative_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_relative_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            RelativeSelector {
-                span,
-                combinator,
-                selector,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Combinator> as VisitWith<V>>::visit_with(combinator, visitor)
-                };
-                {
-                    <ComplexSelector as VisitWith<V>>::visit_with(selector, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for RelativeSelectorList {
-    #[doc = "Calls [Visit`::visit_relative_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_relative_selector_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            RelativeSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<RelativeSelector> as VisitWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Resolution {
-    #[doc = "Calls [Visit`::visit_resolution`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_resolution(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Resolution { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Rule {
-    #[doc = "Calls [Visit`::visit_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_rule(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Rule::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Rule::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Rule::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ScopeRange {
-    #[doc = "Calls [Visit`::visit_scope_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_scope_range(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ScopeRange {
-                span,
-                scope_start,
-                scope_end,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<ForgivingSelectorList> as VisitWith<V>>::visit_with(
-                        scope_start,
-                        visitor,
-                    )
-                };
-                {
-                    <Option<ForgivingSelectorList> as VisitWith<V>>::visit_with(scope_end, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SelectorList {
-    #[doc = "Calls [Visit`::visit_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_selector_list(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ComplexSelector> as VisitWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SequenceOfCustomIdents {
-    #[doc = "Calls [Visit`::visit_sequence_of_custom_idents`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_sequence_of_custom_idents(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SequenceOfCustomIdents { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<CustomIdent> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SimpleBlock {
-    #[doc = "Calls [Visit`::visit_simple_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_simple_block(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SimpleBlock { span, name, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TokenAndSpan as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeature {
-    #[doc = "Calls [Visit`::visit_size_feature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeature::Plain { 0: _field_0 } => {
-                <SizeFeaturePlain as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SizeFeature::Boolean { 0: _field_0 } => {
-                <SizeFeatureBoolean as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SizeFeature::Range { 0: _field_0 } => {
-                <SizeFeatureRange as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SizeFeature::RangeInterval { 0: _field_0 } => {
-                <SizeFeatureRangeInterval as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureBoolean {
-    #[doc = "Calls [Visit`::visit_size_feature_boolean`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature_boolean(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeatureBoolean { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <SizeFeatureName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureName {
-    #[doc = "Calls [Visit`::visit_size_feature_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeatureName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeaturePlain {
-    #[doc = "Calls [Visit`::visit_size_feature_plain`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature_plain(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeaturePlain { span, name, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <SizeFeatureName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureRange {
-    #[doc = "Calls [Visit`::visit_size_feature_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature_range(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeatureRange {
-                span,
-                left,
-                comparison,
-                right,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <SizeFeatureRangeComparison as VisitWith<V>>::visit_with(comparison, visitor)
-                };
-                {
-                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureRangeComparison {
-    #[doc = "Calls [Visit`::visit_size_feature_range_comparison`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature_range_comparison(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeatureRangeComparison::Lt => {}
-            SizeFeatureRangeComparison::Le => {}
-            SizeFeatureRangeComparison::Gt => {}
-            SizeFeatureRangeComparison::Ge => {}
-            SizeFeatureRangeComparison::Eq => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureRangeInterval {
-    #[doc = "Calls [Visit`::visit_size_feature_range_interval`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature_range_interval(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeatureRangeInterval {
-                span,
-                left,
-                left_comparison,
-                name,
-                right_comparison,
-                right,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <SizeFeatureRangeComparison as VisitWith<V>>::visit_with(
-                        left_comparison,
-                        visitor,
-                    )
-                };
-                {
-                    <SizeFeatureName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <SizeFeatureRangeComparison as VisitWith<V>>::visit_with(
-                        right_comparison,
-                        visitor,
-                    )
-                };
-                {
-                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureValue {
-    #[doc = "Calls [Visit`::visit_size_feature_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_size_feature_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SizeFeatureValue::Number { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SizeFeatureValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SizeFeatureValue::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SizeFeatureValue::Ratio { 0: _field_0 } => {
-                <Ratio as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SizeFeatureValue::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Str {
-    #[doc = "Calls [Visit`::visit_str`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_str(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Str { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for StyleBlock {
-    #[doc = "Calls [Visit`::visit_style_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_style_block(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            StyleBlock::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            StyleBlock::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            StyleBlock::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            StyleBlock::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Stylesheet {
-    #[doc = "Calls [Visit`::visit_stylesheet`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_stylesheet(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Stylesheet { span, rules } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Rule> as VisitWith<V>>::visit_with(rules, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SubclassSelector {
-    #[doc = "Calls [Visit`::visit_subclass_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_subclass_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SubclassSelector::Id { 0: _field_0 } => {
-                <IdSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SubclassSelector::Class { 0: _field_0 } => {
-                <ClassSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SubclassSelector::Attribute { 0: _field_0 } => {
-                <Box<AttributeSelector> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SubclassSelector::PseudoClass { 0: _field_0 } => {
-                <PseudoClassSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SubclassSelector::PseudoElement { 0: _field_0 } => {
-                <PseudoElementSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SupportsAnd {
-    #[doc = "Calls [Visit`::visit_supports_and`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_and(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SupportsAnd {
-                span,
-                keyword,
-                condition,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <Box<SupportsInParens> as VisitWith<V>>::visit_with(condition, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SupportsCondition {
-    #[doc = "Calls [Visit`::visit_supports_condition`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_condition(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SupportsCondition { span, conditions } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<SupportsConditionType> as VisitWith<V>>::visit_with(conditions, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SupportsConditionType {
-    #[doc = "Calls [Visit`::visit_supports_condition_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_condition_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SupportsConditionType::Not { 0: _field_0 } => {
-                <SupportsNot as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SupportsConditionType::And { 0: _field_0 } => {
-                <SupportsAnd as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SupportsConditionType::Or { 0: _field_0 } => {
-                <SupportsOr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SupportsConditionType::SupportsInParens { 0: _field_0 } => {
-                <SupportsInParens as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SupportsFeature {
-    #[doc = "Calls [Visit`::visit_supports_feature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_feature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SupportsFeature::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SupportsFeature::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SupportsInParens {
-    #[doc = "Calls [Visit`::visit_supports_in_parens`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_in_parens(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SupportsInParens::SupportsCondition { 0: _field_0 } => {
-                <SupportsCondition as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SupportsInParens::Feature { 0: _field_0 } => {
-                <SupportsFeature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SupportsInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SupportsNot {
-    #[doc = "Calls [Visit`::visit_supports_not`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_not(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SupportsNot {
-                span,
-                keyword,
-                condition,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <Box<SupportsInParens> as VisitWith<V>>::visit_with(condition, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SupportsOr {
-    #[doc = "Calls [Visit`::visit_supports_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_or(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SupportsOr {
-                span,
-                keyword,
-                condition,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
-                };
-                {
-                    <Box<SupportsInParens> as VisitWith<V>>::visit_with(condition, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TagNameSelector {
-    #[doc = "Calls [Visit`::visit_tag_name_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_tag_name_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TagNameSelector { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <WqName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Time {
-    #[doc = "Calls [Visit`::visit_time`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_time(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Time { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TimePercentage {
-    #[doc = "Calls [Visit`::visit_time_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_time_percentage(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TimePercentage::Time { 0: _field_0 } => {
-                <Time as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TimePercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Token {
-    #[doc = "Calls [Visit`::visit_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_token(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Token::Ident { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Function { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::AtKeyword { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Hash { is_id, value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::String { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::BadString { raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Url { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Box<UrlKeyValue> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::BadUrl { raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Delim { value } => {}
-            Token::Number {
-                value,
-                raw,
-                type_flag,
-            } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-                {
-                    <NumberType as VisitWith<V>>::visit_with(type_flag, visitor)
-                };
-            }
-            Token::Percentage { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Dimension { 0: _field_0 } => {
-                <Box<DimensionToken> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Token::WhiteSpace { value } => {
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-            Token::CDO => {}
-            Token::CDC => {}
-            Token::Colon => {}
-            Token::Semi => {}
-            Token::Comma => {}
-            Token::LBracket => {}
-            Token::RBracket => {}
-            Token::LParen => {}
-            Token::RParen => {}
-            Token::LBrace => {}
-            Token::RBrace => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TokenAndSpan {
-    #[doc = "Calls [Visit`::visit_token_and_span`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_token_and_span(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TokenAndSpan { span, token } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Token as VisitWith<V>>::visit_with(token, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TypeSelector {
-    #[doc = "Calls [Visit`::visit_type_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_type_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TypeSelector::TagName { 0: _field_0 } => {
-                <TagNameSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TypeSelector::Universal { 0: _field_0 } => {
-                <UniversalSelector as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UnicodeRange {
-    #[doc = "Calls [Visit`::visit_unicode_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_unicode_range(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UnicodeRange {
-                span,
-                start,
-                end,
-                raw,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(start, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(end, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UniversalSelector {
-    #[doc = "Calls [Visit`::visit_universal_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_universal_selector(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UniversalSelector { span, prefix } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<NamespacePrefix> as VisitWith<V>>::visit_with(prefix, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UnknownDimension {
-    #[doc = "Calls [Visit`::visit_unknown_dimension`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_unknown_dimension(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UnknownDimension { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Number as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Url {
-    #[doc = "Calls [Visit`::visit_url`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_url(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Url {
-                span,
-                name,
-                value,
-                modifiers,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<Box<UrlValue>> as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<Vec<UrlModifier>> as VisitWith<V>>::visit_with(modifiers, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UrlKeyValue {
-    #[doc = "Calls [Visit`::visit_url_key_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_url_key_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UrlKeyValue {
-                0: _field_0,
-                1: _field_1,
-            } => {
-                <swc_atoms::Atom as VisitWith<V>>::visit_with(_field_0, visitor);
-                <swc_atoms::Atom as VisitWith<V>>::visit_with(_field_1, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UrlModifier {
-    #[doc = "Calls [Visit`::visit_url_modifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_url_modifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UrlModifier::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            UrlModifier::Function { 0: _field_0 } => {
-                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UrlValue {
-    #[doc = "Calls [Visit`::visit_url_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_url_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UrlValue::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            UrlValue::Raw { 0: _field_0 } => {
-                <UrlValueRaw as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UrlValueRaw {
-    #[doc = "Calls [Visit`::visit_url_value_raw`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_url_value_raw(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UrlValueRaw { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for WqName {
-    #[doc = "Calls [Visit`::visit_wq_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_wq_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            WqName {
-                span,
-                prefix,
-                value,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<NamespacePrefix> as VisitWith<V>>::visit_with(prefix, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [Visit`::visit_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [CalcProductOrOperator] {
-    #[doc = "Calls [Visit`::visit_calc_product_or_operators`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_product_or_operators(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CalcProductOrOperator as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [CalcValueOrOperator] {
-    #[doc = "Calls [Visit`::visit_calc_value_or_operators`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_calc_value_or_operators(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CalcValueOrOperator as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ComplexSelectorChildren] {
-    #[doc = "Calls [Visit`::visit_complex_selector_childrens`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_complex_selector_childrens(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ComplexSelectorChildren as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ComplexSelector] {
-    #[doc = "Calls [Visit`::visit_complex_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_complex_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ComplexSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ComponentValue] {
-    #[doc = "Calls [Visit`::visit_component_values`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_component_values(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ComponentValue as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [CompoundSelector] {
-    #[doc = "Calls [Visit`::visit_compound_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_compound_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CompoundSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ContainerQueryType] {
-    #[doc = "Calls [Visit`::visit_container_query_types`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_container_query_types(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ContainerQueryType as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [CustomIdent] {
-    #[doc = "Calls [Visit`::visit_custom_idents`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_custom_idents(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CustomIdent as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [DocumentPreludeMatchingFunction] {
-    #[doc = "Calls [Visit`::visit_document_prelude_matching_functions`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_document_prelude_matching_functions(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <DocumentPreludeMatchingFunction as VisitWith<V>>::visit_with(item, visitor)
-        })
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [FamilyName] {
-    #[doc = "Calls [Visit`::visit_family_names`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_family_names(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <FamilyName as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ForgivingComplexSelector] {
-    #[doc = "Calls [Visit`::visit_forgiving_complex_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_forgiving_complex_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ForgivingComplexSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ForgivingRelativeSelector] {
-    #[doc = "Calls [Visit`::visit_forgiving_relative_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_forgiving_relative_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ForgivingRelativeSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Ident] {
-    #[doc = "Calls [Visit`::visit_idents`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_idents(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Ident as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [KeyframeSelector] {
-    #[doc = "Calls [Visit`::visit_keyframe_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_keyframe_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <KeyframeSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [LayerName] {
-    #[doc = "Calls [Visit`::visit_layer_names`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_layer_names(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <LayerName as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [MediaConditionAllType] {
-    #[doc = "Calls [Visit`::visit_media_condition_all_types`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_condition_all_types(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <MediaConditionAllType as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [MediaConditionWithoutOrType] {
-    #[doc = "Calls [Visit`::visit_media_condition_without_or_types`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_condition_without_or_types(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <MediaConditionWithoutOrType as VisitWith<V>>::visit_with(item, visitor)
-        })
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [MediaQuery] {
-    #[doc = "Calls [Visit`::visit_media_querys`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_media_querys(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <MediaQuery as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<AtRulePrelude>> {
-    #[doc = "Calls [Visit`::visit_opt_at_rule_prelude`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_at_rule_prelude(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<AtRulePrelude> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [Visit`::visit_opt_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_atoms::Atom as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorMatcher> {
-    #[doc = "Calls [Visit`::visit_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_attribute_selector_matcher(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <AttributeSelectorMatcher as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorModifier> {
-    #[doc = "Calls [Visit`::visit_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_attribute_selector_modifier(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <AttributeSelectorModifier as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorValue> {
-    #[doc = "Calls [Visit`::visit_opt_attribute_selector_value`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_attribute_selector_value(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <AttributeSelectorValue as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Combinator> {
-    #[doc = "Calls [Visit`::visit_opt_combinator`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_combinator(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Combinator as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<ContainerName> {
-    #[doc = "Calls [Visit`::visit_opt_container_name`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_container_name(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ContainerName as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<ForgivingSelectorList> {
-    #[doc = "Calls [Visit`::visit_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_forgiving_selector_list(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ForgivingSelectorList as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Function>> {
-    #[doc = "Calls [Visit`::visit_opt_function`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_function(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Function> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Ident> {
-    #[doc = "Calls [Visit`::visit_opt_ident`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ident(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Ident as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ImportConditions>> {
-    #[doc = "Calls [Visit`::visit_opt_import_conditions`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_import_conditions(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<ImportConditions> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ImportLayerName>> {
-    #[doc = "Calls [Visit`::visit_opt_import_layer_name`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_import_layer_name(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<ImportLayerName> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<ImportantFlag> {
-    #[doc = "Calls [Visit`::visit_opt_important_flag`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_important_flag(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ImportantFlag as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<MediaConditionType>> {
-    #[doc = "Calls [Visit`::visit_opt_media_condition_type`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_media_condition_type(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<MediaConditionType> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<MediaQueryList>> {
-    #[doc = "Calls [Visit`::visit_opt_media_query_list`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_media_query_list(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<MediaQueryList> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<MediaType> {
-    #[doc = "Calls [Visit`::visit_opt_media_type`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_media_type(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <MediaType as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Namespace> {
-    #[doc = "Calls [Visit`::visit_opt_namespace`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_namespace(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Namespace as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<NamespacePrefix> {
-    #[doc = "Calls [Visit`::visit_opt_namespace_prefix`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_namespace_prefix(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <NamespacePrefix as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<NestingSelector> {
-    #[doc = "Calls [Visit`::visit_opt_nesting_selector`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_nesting_selector(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <NestingSelector as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Number> {
-    #[doc = "Calls [Visit`::visit_opt_number`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_number(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Number as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PageSelectorPseudo>> {
-    #[doc = "Calls [Visit`::visit_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_page_selector_pseudos(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Vec<PageSelectorPseudo> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<PageSelectorType> {
-    #[doc = "Calls [Visit`::visit_opt_page_selector_type`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_page_selector_type(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <PageSelectorType as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
-    #[doc = "Calls [Visit`::visit_opt_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_pseudo_class_selector_childrens(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <Vec<PseudoClassSelectorChildren> as VisitWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
-    #[doc = "Calls [Visit`::visit_opt_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_pseudo_element_selector_childrens(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <Vec<PseudoElementSelectorChildren> as VisitWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<SimpleBlock> {
-    #[doc = "Calls [Visit`::visit_opt_simple_block`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_simple_block(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <SimpleBlock as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TypeSelector>> {
-    #[doc = "Calls [Visit`::visit_opt_type_selector`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_type_selector(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TypeSelector> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<UrlModifier>> {
-    #[doc = "Calls [Visit`::visit_opt_url_modifiers`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_url_modifiers(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Vec<UrlModifier> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<UrlValue>> {
-    #[doc = "Calls [Visit`::visit_opt_url_value`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_url_value(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<UrlValue> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [PageSelectorPseudo] {
-    #[doc = "Calls [Visit`::visit_page_selector_pseudos`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_page_selector_pseudos(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <PageSelectorPseudo as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [PageSelector] {
-    #[doc = "Calls [Visit`::visit_page_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_page_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <PageSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [PseudoClassSelectorChildren] {
-    #[doc = "Calls [Visit`::visit_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pseudo_class_selector_childrens(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <PseudoClassSelectorChildren as VisitWith<V>>::visit_with(item, visitor)
-        })
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [PseudoElementSelectorChildren] {
-    #[doc = "Calls [Visit`::visit_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pseudo_element_selector_childrens(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <PseudoElementSelectorChildren as VisitWith<V>>::visit_with(item, visitor)
-        })
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [RelativeSelector] {
-    #[doc = "Calls [Visit`::visit_relative_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_relative_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <RelativeSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Rule] {
-    #[doc = "Calls [Visit`::visit_rules`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_rules(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Rule as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for swc_common::Span {
-    #[doc = "Calls [Visit`::visit_span`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_span(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [SubclassSelector] {
-    #[doc = "Calls [Visit`::visit_subclass_selectors`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_subclass_selectors(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <SubclassSelector as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [SupportsConditionType] {
-    #[doc = "Calls [Visit`::visit_supports_condition_types`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_supports_condition_types(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <SupportsConditionType as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [UrlModifier] {
-    #[doc = "Calls [Visit`::visit_url_modifiers`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_url_modifiers(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <UrlModifier as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V, T> VisitWith<V> for std::boxed::Box<T>
-where
-    V: ?Sized + Visit,
-    T: VisitWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <T as VisitWith<V>>::visit_with(&**self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <T as VisitWith<V>>::visit_children_with(&**self, visitor);
-        v
-    }
-}
-impl<V, T> VisitWith<V> for std::vec::Vec<T>
-where
-    V: ?Sized + Visit,
-    [T]: VisitWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitWith<V>>::visit_with(self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitWith<V>>::visit_children_with(self, visitor);
-        v
-    }
-}
-#[doc = r" A visitor trait for traversing the AST."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitAstPath {
-    #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
-             [`AbsoluteColorBase::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_absolute_color_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AbsoluteColorBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AbsoluteColorBase as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
-             [`AlphaValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_alpha_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AlphaValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AlphaValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
-             [`AnPlusB::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_an_plus_b<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusB,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AnPlusB as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
-             [`AnPlusBNotation::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusBNotation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AnPlusBNotation as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
-             [`Angle::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
-        <Angle as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
-             [`AnglePercentage::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_angle_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnglePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AnglePercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
-             [`AnyNamespace::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_any_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnyNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AnyNamespace as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
-             [`AtRule::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AtRule as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
-             [`AtRuleName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_at_rule_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AtRuleName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
-             [`AtRulePrelude::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AtRulePrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <swc_atoms::Atom as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
-             [`AttributeSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_attribute_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AttributeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
-             [`AttributeSelectorMatcher::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcher,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AttributeSelectorMatcher as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
-             calls [`AttributeSelectorMatcherValue::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcherValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AttributeSelectorMatcherValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
-             [`AttributeSelectorModifier::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AttributeSelectorModifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
-             [`AttributeSelectorValue::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AttributeSelectorValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
-             [`BinOp::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
-        <BinOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
-             [`CalcOperator::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_calc_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CalcOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
-             [`CalcOperatorType::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_calc_operator_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperatorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CalcOperatorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
-             [`CalcProduct::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_calc_product<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProduct,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CalcProduct as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
-             [`CalcProductOrOperator::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProductOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CalcProductOrOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
-             calls [`Vec < CalcProductOrOperator >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcProductOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[CalcProductOrOperator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
-             [`CalcSum::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_calc_sum<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcSum,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CalcSum as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
-             [`CalcValue::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_calc_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CalcValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
-             [`CalcValueOrOperator::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValueOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CalcValueOrOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
-             [`Vec < CalcValueOrOperator >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcValueOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[CalcValueOrOperator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
-             [`ClassSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ClassSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
-             [`CmykComponent::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_cmyk_component<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CmykComponent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CmykComponent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
-             [`Color::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
-        <Color as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
-             [`ColorProfileName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_color_profile_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ColorProfileName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ColorProfileName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
-             [`Combinator::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Combinator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Combinator as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
-             [`CombinatorValue::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_combinator_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CombinatorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CombinatorValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
-             [`ComplexSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ComplexSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
-             [`ComplexSelectorChildren::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_complex_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ComplexSelectorChildren as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
-             calls [`Vec < ComplexSelectorChildren >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ComplexSelectorChildren] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
-             [`Vec < ComplexSelector >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ComplexSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
-             [`ComponentValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_component_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComponentValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ComponentValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
-             < ComponentValue >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComponentValue],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ComponentValue] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
-             [`CompoundSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_compound_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CompoundSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
-             [`CompoundSelectorList::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_compound_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CompoundSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
-             [`Vec < CompoundSelector >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_compound_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CompoundSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[CompoundSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
-             [`ContainerCondition::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_container_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContainerCondition as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
-             [`ContainerName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContainerName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
-             [`ContainerQuery::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_container_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContainerQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
-             [`ContainerQueryAnd::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_container_query_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContainerQueryAnd as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
-             [`ContainerQueryNot::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_container_query_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContainerQueryNot as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
-             [`ContainerQueryOr::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_container_query_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContainerQueryOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
-             [`ContainerQueryType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_container_query_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContainerQueryType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
-             [`Vec < ContainerQueryType >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_container_query_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ContainerQueryType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ContainerQueryType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
-             [`CustomHighlightName::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_custom_highlight_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomHighlightName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CustomHighlightName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
-             [`CustomIdent::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_custom_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CustomIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
-             CustomIdent >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CustomIdent],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[CustomIdent] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
-             [`CustomMediaQuery::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_custom_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CustomMediaQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
-             [`CustomMediaQueryMediaType::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQueryMediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CustomMediaQueryMediaType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
-             [`CustomPropertyName::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_custom_property_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomPropertyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CustomPropertyName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
-             [`DashedIdent::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_dashed_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DashedIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DashedIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
-             [`Declaration::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_declaration<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Declaration,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Declaration as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
-             [`DeclarationName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_declaration_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DeclarationName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
-             [`DeclarationOrAtRule::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationOrAtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DeclarationOrAtRule as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
-             [`Delimiter::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_delimiter<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Delimiter,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Delimiter as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
-             [`DelimiterValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_delimiter_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DelimiterValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DelimiterValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
-             [`Dimension::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Dimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Dimension as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
-             [`DimensionToken::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_dimension_token<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DimensionToken,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DimensionToken as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
-             [`DocumentPrelude::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_document_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DocumentPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
-             calls [`DocumentPreludeMatchingFunction::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DocumentPreludeMatchingFunction as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
-             method calls [`Vec < DocumentPreludeMatchingFunction \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [DocumentPreludeMatchingFunction],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[DocumentPreludeMatchingFunction] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
-             [`ExtensionName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_extension_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExtensionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExtensionName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
-             [`FamilyName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_family_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FamilyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <FamilyName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
-             FamilyName >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_family_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [FamilyName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[FamilyName] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
-             [`Flex::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
-        <Flex as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
-             [`FontFeatureValuesPrelude::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FontFeatureValuesPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <FontFeatureValuesPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
-             [`ForgivingComplexSelector::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForgivingComplexSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingComplexSelector >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ForgivingComplexSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
-             [`ForgivingRelativeSelector::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForgivingRelativeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
-             calls [`ForgivingRelativeSelectorList::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForgivingRelativeSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingRelativeSelector >::visit_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingRelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ForgivingRelativeSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
-             [`ForgivingSelectorList::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForgivingSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
-             [`Frequency::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_frequency<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Frequency,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Frequency as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
-             [`FrequencyPercentage::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_frequency_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FrequencyPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <FrequencyPercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Function as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
-             [`FunctionName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_function_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FunctionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <FunctionName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
-             [`GeneralEnclosed::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_general_enclosed<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GeneralEnclosed,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <GeneralEnclosed as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
-             [`HexColor::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_hex_color<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast HexColor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <HexColor as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
-             [`Hue::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
-        <Hue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
-             [`IdSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_id_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <IdSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        <Ident as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Ident],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[Ident] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
-             [`ImportConditions::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportConditions,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportConditions as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
-             [`ImportHref::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_import_href<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportHref,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportHref as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
-             [`ImportLayerName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportLayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportLayerName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
-             [`ImportPrelude::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_import_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
-             [`ImportantFlag::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportantFlag,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportantFlag as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
-             [`Integer::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_integer<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Integer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Integer as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
-             [`KeyframeBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_keyframe_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <KeyframeBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
-             [`KeyframeSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_keyframe_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <KeyframeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
-             [`Vec < KeyframeSelector >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_keyframe_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [KeyframeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[KeyframeSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
-             [`KeyframesName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_keyframes_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <KeyframesName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
-             [`KeyframesPseudoFunction::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <KeyframesPseudoFunction as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
-             [`KeyframesPseudoPrefix::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoPrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <KeyframesPseudoPrefix as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
-             [`LayerName::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <LayerName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
-             [`LayerNameList::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_layer_name_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerNameList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <LayerNameList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
-             LayerName >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_layer_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [LayerName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[LayerName] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
-             [`LayerPrelude::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_layer_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <LayerPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
-             [`Length::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
-        <Length as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
-             [`LengthPercentage::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_length_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LengthPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <LengthPercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
-             [`ListOfComponentValues::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_list_of_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ListOfComponentValues,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ListOfComponentValues as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
-             [`MediaAnd::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_media_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaAnd as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
-             [`MediaCondition::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_media_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaCondition as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
-             [`MediaConditionAllType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_media_condition_all_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionAllType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaConditionAllType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
-             calls [`Vec < MediaConditionAllType >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_media_condition_all_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionAllType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[MediaConditionAllType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
-             [`MediaConditionType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaConditionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOr::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_media_condition_without_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaConditionWithoutOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOrType::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOrType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaConditionWithoutOrType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
-             method calls [`Vec < MediaConditionWithoutOrType >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionWithoutOrType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[MediaConditionWithoutOrType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
-             [`MediaFeature::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_media_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
-             [`MediaFeatureBoolean::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_media_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeatureBoolean as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
-             [`MediaFeatureName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_media_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeatureName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
-             [`MediaFeaturePlain::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_media_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeaturePlain as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
-             [`MediaFeatureRange::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_media_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeatureRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeComparison::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeatureRangeComparison as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeInterval::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeatureRangeInterval as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
-             [`MediaFeatureValue::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_media_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaFeatureValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
-             [`MediaInParens::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_media_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaInParens as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
-             [`MediaNot::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_media_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaNot as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
-             [`MediaOr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_media_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
-             [`MediaQuery::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
-             [`MediaQueryList::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQueryList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaQueryList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
-             MediaQuery >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_media_querys<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaQuery],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[MediaQuery] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
-             [`MediaType::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MediaType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
-             [`NamedNamespace::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_named_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NamedNamespace as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Namespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Namespace as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
-             [`NamespacePrefix::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NamespacePrefix as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
-             [`NamespacePrelude::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_namespace_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NamespacePrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
-             [`NamespacePreludeUri::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePreludeUri,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NamespacePreludeUri as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
-             [`NestingSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NestingSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NestingSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        <Number as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
-             [`NumberType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_number_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NumberType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NumberType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
-             calls [`Option < Box < AtRulePrelude > >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<AtRulePrelude>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<swc_atoms::Atom> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorMatcher >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<AttributeSelectorMatcher> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorModifier >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<AttributeSelectorModifier> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
-             calls [`Option < AttributeSelectorValue >::visit_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<AttributeSelectorValue> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
-             [`Option < Combinator >::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_opt_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Combinator>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Combinator> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
-             [`Option < ContainerName >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ContainerName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<ContainerName> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
-             calls [`Option < ForgivingSelectorList >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ForgivingSelectorList>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<ForgivingSelectorList> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
-             [`Option < Box < Function > >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Function>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<Function>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Ident> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
-             method calls [`Option < Box < ImportConditions > >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportConditions>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<ImportConditions>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
-             calls [`Option < Box < ImportLayerName > >::visit_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<ImportLayerName>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
-             [`Option < ImportantFlag >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ImportantFlag>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<ImportantFlag> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
-             method calls [`Option < Box < MediaConditionType > >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<MediaConditionType>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
-             calls [`Option < Box < MediaQueryList > >::visit_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<MediaQueryList>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
-             [`Option < MediaType >::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_opt_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<MediaType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<MediaType> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_opt_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Namespace>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Namespace> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
-             [`Option < NamespacePrefix >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NamespacePrefix>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<NamespacePrefix> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
-             [`Option < NestingSelector >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NestingSelector>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<NestingSelector> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
-             Number >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_opt_number<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Number>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Number> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
-             method calls [`Option < Vec < PageSelectorPseudo > >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Vec<PageSelectorPseudo>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
-             [`Option < PageSelectorType >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<PageSelectorType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<PageSelectorType> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
-             this method calls [`Option < Vec < PseudoClassSelectorChildren > \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        < Option < Vec < PseudoClassSelectorChildren > > as VisitWithAstPath < Self > > :: visit_children_with_ast_path (node , self , __ast_path)
-    }
-    #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
-             default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        < Option < Vec < PseudoElementSelectorChildren > > as VisitWithAstPath < Self > > :: visit_children_with_ast_path (node , self , __ast_path)
-    }
-    #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
-             [`Option < SimpleBlock >::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_opt_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<SimpleBlock>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<SimpleBlock> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
-             calls [`Option < Box < TypeSelector > >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TypeSelector>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<TypeSelector>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
-             calls [`Option < Vec < UrlModifier > >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Vec<UrlModifier>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
-             [`Option < Box < UrlValue > >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<UrlValue>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<UrlValue>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
-             [`PageSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_page_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PageSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
-             [`PageSelectorList::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_page_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PageSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
-             [`PageSelectorPseudo::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorPseudo,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PageSelectorPseudo as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
-             [`Vec < PageSelectorPseudo >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelectorPseudo],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[PageSelectorPseudo] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
-             [`PageSelectorType::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PageSelectorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
-             PageSelector >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_page_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[PageSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
-             [`Percentage::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Percentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Percentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
-             [`PseudoClassSelector::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PseudoClassSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
-             [`PseudoClassSelectorChildren::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PseudoClassSelectorChildren as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoClassSelectorChildren >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoClassSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[PseudoClassSelectorChildren] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
-             [`PseudoElementSelector::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PseudoElementSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
-             calls [`PseudoElementSelectorChildren::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PseudoElementSelectorChildren as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoElementSelectorChildren >::visit_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoElementSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[PseudoElementSelectorChildren] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
-             [`QualifiedRule::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_qualified_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <QualifiedRule as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
-             [`QualifiedRulePrelude::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <QualifiedRulePrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
-             [`QueryInParens::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_query_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QueryInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <QueryInParens as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
-             [`Ratio::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
-        <Ratio as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
-             [`RelativeSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <RelativeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
-             [`RelativeSelectorList::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <RelativeSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
-             [`Vec < RelativeSelector >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [RelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[RelativeSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
-             [`Resolution::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_resolution<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Resolution,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Resolution as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
-             [`Rule::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
-        <Rule as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
-        <[Rule] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
-             [`ScopeRange::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_scope_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ScopeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ScopeRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
-             [`SelectorList::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
-             [`SequenceOfCustomIdents::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SequenceOfCustomIdents,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SequenceOfCustomIdents as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
-             [`SimpleBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SimpleBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
-             [`SizeFeature::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_size_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
-             [`SizeFeatureBoolean::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_size_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeatureBoolean as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
-             [`SizeFeatureName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_size_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeatureName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
-             [`SizeFeaturePlain::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_size_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeaturePlain as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
-             [`SizeFeatureRange::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_size_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeatureRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeComparison::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeatureRangeComparison as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeInterval::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeatureRangeInterval as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
-             [`SizeFeatureValue::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_size_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SizeFeatureValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <swc_common::Span as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        <Str as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
-             [`StyleBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_style_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StyleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <StyleBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
-             [`Stylesheet::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_stylesheet<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Stylesheet,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Stylesheet as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
-             [`SubclassSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_subclass_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SubclassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SubclassSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
-             [`Vec < SubclassSelector >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_subclass_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SubclassSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[SubclassSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
-             [`SupportsAnd::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_supports_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SupportsAnd as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
-             [`SupportsCondition::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_supports_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SupportsCondition as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
-             [`SupportsConditionType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_supports_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SupportsConditionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
-             calls [`Vec < SupportsConditionType >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_supports_condition_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SupportsConditionType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[SupportsConditionType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
-             [`SupportsFeature::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_supports_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SupportsFeature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
-             [`SupportsInParens::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_supports_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SupportsInParens as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
-             [`SupportsNot::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_supports_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SupportsNot as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
-             [`SupportsOr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_supports_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SupportsOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
-             [`TagNameSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_tag_name_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TagNameSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TagNameSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
-             [`Time::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
-        <Time as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
-             [`TimePercentage::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_time_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TimePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TimePercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
-        <Token as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_token_and_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TokenAndSpan,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TokenAndSpan as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
-             [`TypeSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TypeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TypeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
-             [`UnicodeRange::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_unicode_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnicodeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UnicodeRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
-             [`UniversalSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_universal_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UniversalSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UniversalSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
-             [`UnknownDimension::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_unknown_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnknownDimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UnknownDimension as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
-             [`Url::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
-        <Url as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
-             [`UrlKeyValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_url_key_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlKeyValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UrlKeyValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
-             [`UrlModifier::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_url_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UrlModifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
-             UrlModifier >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [UrlModifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[UrlModifier] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
-             [`UrlValue::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UrlValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
-             [`UrlValueRaw::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_url_value_raw<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValueRaw,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UrlValueRaw as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
-             [`WqName::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_wq_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WqName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <WqName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for &mut V
-where
-    V: ?Sized + VisitAstPath,
-{
-    #[inline]
-    fn visit_absolute_color_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AbsoluteColorBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_absolute_color_base(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_alpha_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AlphaValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_alpha_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_an_plus_b<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusB,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_an_plus_b(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusBNotation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_an_plus_b_notation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_angle(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_angle_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnglePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_angle_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_any_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnyNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_any_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_at_rule_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcher,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_matcher(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcherValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_matcher_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_modifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_bin_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_operator_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperatorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_operator_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_product<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProduct,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProductOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product_or_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcProductOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product_or_operators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_sum<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcSum,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_sum(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValueOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value_or_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcValueOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value_or_operators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_cmyk_component<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CmykComponent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_cmyk_component(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_color(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_color_profile_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ColorProfileName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_color_profile_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Combinator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_combinator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_combinator_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CombinatorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_combinator_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector_children(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector_childrens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_component_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComponentValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_component_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComponentValue],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_component_values(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_compound_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_compound_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_compound_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CompoundSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_condition(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_and(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_not(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ContainerQueryType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_highlight_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomHighlightName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_highlight_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CustomIdent],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_idents(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_media_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQueryMediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_media_query_media_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_property_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomPropertyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_property_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_dashed_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DashedIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dashed_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_declaration<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Declaration,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_declaration_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationOrAtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration_or_at_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_delimiter<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Delimiter,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_delimiter(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_delimiter_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DelimiterValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_delimiter_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Dimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dimension(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_dimension_token<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DimensionToken,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dimension_token(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_document_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude_matching_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [DocumentPreludeMatchingFunction],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude_matching_functions(
-            &mut **self,
-            node,
-            __ast_path,
-        )
-    }
-
-    #[inline]
-    fn visit_extension_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExtensionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_extension_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_family_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FamilyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_family_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_family_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [FamilyName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_family_names(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_flex(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FontFeatureValuesPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_font_feature_values_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_complex_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_complex_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingRelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_frequency<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Frequency,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_frequency(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_frequency_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FrequencyPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_frequency_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_function_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FunctionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_general_enclosed<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GeneralEnclosed,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_general_enclosed(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_hex_color<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast HexColor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_hex_color(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_hue(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_id_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_id_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Ident],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_idents(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportConditions,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_conditions(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_href<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportHref,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_href(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportLayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_layer_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportantFlag,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_important_flag(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_integer<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Integer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_integer(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframe_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframe_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframe_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [KeyframeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframes_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_pseudo_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoPrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_name_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerNameList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_name_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [LayerName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_names(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_length(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_length_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LengthPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_length_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_list_of_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ListOfComponentValues,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_list_of_component_values(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_and(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_all_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionAllType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_all_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_all_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionAllType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_all_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOrType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionWithoutOrType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_boolean(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_plain(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range_comparison(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range_interval(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_in_parens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_not(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQueryList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_query_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_querys<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaQuery],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_querys(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_named_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_named_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Namespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prefix(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePreludeUri,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prelude_uri(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NestingSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_nesting_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_number_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NumberType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_number_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_at_rule_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Combinator>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_combinator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ContainerName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_container_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ForgivingSelectorList>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_forgiving_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Function>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportConditions>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_import_conditions(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_import_layer_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ImportantFlag>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_important_flag(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_condition_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_query_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<MediaType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Namespace>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NamespacePrefix>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_namespace_prefix(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NestingSelector>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_nesting_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_number<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Number>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_number(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_page_selector_pseudos(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<PageSelectorType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_page_selector_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
-    }
-
-    #[inline]
-    fn visit_opt_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<SimpleBlock>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_simple_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TypeSelector>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_type_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_url_modifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<UrlValue>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_url_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorPseudo,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_pseudo(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelectorPseudo],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_pseudos(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Percentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector_children(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoClassSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector_children(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoElementSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_qualified_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_qualified_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_qualified_rule_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_query_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QueryInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_query_in_parens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ratio(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [RelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_resolution<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Resolution,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_resolution(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_rules(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_scope_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ScopeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_scope_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SequenceOfCustomIdents,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_sequence_of_custom_idents(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_simple_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_boolean(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_plain(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range_comparison(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range_interval(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_style_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StyleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_style_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_stylesheet<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Stylesheet,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_stylesheet(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_subclass_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SubclassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_subclass_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_subclass_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SubclassSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_subclass_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_and(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_condition_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SupportsConditionType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_feature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_in_parens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_not(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tag_name_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TagNameSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tag_name_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_time(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_time_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TimePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_time_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_token(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_token_and_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TokenAndSpan,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_token_and_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TypeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_type_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unicode_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnicodeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unicode_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_universal_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UniversalSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_universal_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unknown_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnknownDimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unknown_dimension(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_url(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_key_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlKeyValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_key_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_modifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [UrlModifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_modifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_value_raw<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValueRaw,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_value_raw(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_wq_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WqName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_wq_name(&mut **self, node, __ast_path)
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for Box<V>
-where
-    V: ?Sized + VisitAstPath,
-{
-    #[inline]
-    fn visit_absolute_color_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AbsoluteColorBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_absolute_color_base(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_alpha_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AlphaValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_alpha_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_an_plus_b<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusB,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_an_plus_b(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusBNotation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_an_plus_b_notation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_angle(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_angle_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnglePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_angle_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_any_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnyNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_any_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_at_rule_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcher,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_matcher(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcherValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_matcher_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_modifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_bin_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_operator_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperatorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_operator_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_product<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProduct,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProductOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product_or_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcProductOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product_or_operators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_sum<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcSum,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_sum(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValueOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value_or_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcValueOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value_or_operators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_cmyk_component<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CmykComponent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_cmyk_component(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_color(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_color_profile_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ColorProfileName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_color_profile_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Combinator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_combinator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_combinator_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CombinatorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_combinator_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector_children(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector_childrens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_component_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComponentValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_component_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComponentValue],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_component_values(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_compound_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_compound_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_compound_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CompoundSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_condition(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_and(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_not(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_container_query_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ContainerQueryType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_highlight_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomHighlightName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_highlight_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CustomIdent],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_idents(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_media_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQueryMediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_media_query_media_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_custom_property_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomPropertyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_property_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_dashed_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DashedIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dashed_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_declaration<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Declaration,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_declaration_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationOrAtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration_or_at_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_delimiter<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Delimiter,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_delimiter(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_delimiter_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DelimiterValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_delimiter_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Dimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dimension(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_dimension_token<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DimensionToken,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dimension_token(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_document_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude_matching_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [DocumentPreludeMatchingFunction],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude_matching_functions(
-            &mut **self,
-            node,
-            __ast_path,
-        )
-    }
-
-    #[inline]
-    fn visit_extension_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExtensionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_extension_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_family_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FamilyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_family_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_family_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [FamilyName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_family_names(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_flex(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FontFeatureValuesPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_font_feature_values_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_complex_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_complex_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingRelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_frequency<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Frequency,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_frequency(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_frequency_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FrequencyPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_frequency_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_function_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FunctionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_general_enclosed<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GeneralEnclosed,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_general_enclosed(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_hex_color<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast HexColor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_hex_color(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_hue(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_id_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_id_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Ident],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_idents(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportConditions,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_conditions(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_href<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportHref,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_href(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportLayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_layer_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportantFlag,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_important_flag(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_integer<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Integer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_integer(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframe_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframe_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframe_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [KeyframeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframes_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_pseudo_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoPrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_name_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerNameList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_name_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [LayerName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_names(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_layer_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_length(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_length_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LengthPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_length_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_list_of_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ListOfComponentValues,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_list_of_component_values(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_and(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_all_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionAllType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_all_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_all_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionAllType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_all_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOrType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionWithoutOrType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_boolean(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_plain(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range_comparison(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range_interval(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_in_parens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_not(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQueryList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_query_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_querys<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaQuery],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_querys(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_named_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_named_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Namespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prefix(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePreludeUri,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prelude_uri(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NestingSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_nesting_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_number_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NumberType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_number_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_at_rule_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Combinator>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_combinator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ContainerName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_container_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ForgivingSelectorList>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_forgiving_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Function>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportConditions>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_import_conditions(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_import_layer_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ImportantFlag>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_important_flag(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_condition_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_query_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<MediaType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Namespace>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_namespace(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NamespacePrefix>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_namespace_prefix(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NestingSelector>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_nesting_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_number<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Number>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_number(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_page_selector_pseudos(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<PageSelectorType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_page_selector_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
-    }
-
-    #[inline]
-    fn visit_opt_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<SimpleBlock>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_simple_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TypeSelector>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_type_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_url_modifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<UrlValue>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_url_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorPseudo,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_pseudo(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelectorPseudo],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_pseudos(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_page_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Percentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector_children(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoClassSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector_children(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoElementSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_qualified_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_qualified_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_qualified_rule_prelude(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_query_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QueryInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_query_in_parens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ratio(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [RelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_resolution<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Resolution,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_resolution(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_rule(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_rules(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_scope_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ScopeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_scope_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_selector_list(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SequenceOfCustomIdents,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_sequence_of_custom_idents(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_simple_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_boolean(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_plain(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range_comparison(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range_interval(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_size_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_style_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StyleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_style_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_stylesheet<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Stylesheet,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_stylesheet(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_subclass_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SubclassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_subclass_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_subclass_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SubclassSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_subclass_selectors(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_and(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_condition_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SupportsConditionType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_feature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_in_parens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_not(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_supports_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_or(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tag_name_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TagNameSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tag_name_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_time(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_time_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TimePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_time_percentage(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_token(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_token_and_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TokenAndSpan,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_token_and_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TypeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_type_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unicode_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnicodeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unicode_range(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_universal_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UniversalSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_universal_selector(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unknown_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnknownDimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unknown_dimension(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_url(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_key_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlKeyValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_key_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_modifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [UrlModifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_modifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_url_value_raw<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValueRaw,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_value_raw(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_wq_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WqName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_wq_name(&mut **self, node, __ast_path)
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<A, B> VisitAstPath for ::swc_visit::Either<A, B>
-where
-    A: VisitAstPath,
-    B: VisitAstPath,
-{
-    #[inline]
-    fn visit_absolute_color_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AbsoluteColorBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_absolute_color_base(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_absolute_color_base(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_alpha_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AlphaValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_alpha_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_alpha_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_an_plus_b<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusB,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_an_plus_b(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_an_plus_b(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusBNotation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_an_plus_b_notation(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_an_plus_b_notation(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_angle(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_angle(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_angle_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnglePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_angle_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_angle_percentage(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_any_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnyNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_any_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_any_namespace(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_at_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_at_rule(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_at_rule_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_at_rule_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_at_rule_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_at_rule_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_at_rule_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_atom(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_atom(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_attribute_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_attribute_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcher,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_attribute_selector_matcher(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_attribute_selector_matcher(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcherValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_attribute_selector_matcher_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_attribute_selector_matcher_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_attribute_selector_modifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_attribute_selector_modifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_attribute_selector_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_attribute_selector_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_bin_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_bin_op(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_operator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_operator_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperatorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_operator_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_operator_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_product<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProduct,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_product(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_product(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProductOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_product_or_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_product_or_operator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcProductOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_product_or_operators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_product_or_operators(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_sum<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcSum,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_sum(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_sum(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValueOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_value_or_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_value_or_operator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcValueOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_calc_value_or_operators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_calc_value_or_operators(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_cmyk_component<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CmykComponent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_cmyk_component(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_cmyk_component(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_color(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_color(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_color_profile_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ColorProfileName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_color_profile_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_color_profile_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Combinator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_combinator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_combinator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_combinator_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CombinatorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_combinator_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_combinator_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_complex_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_complex_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_complex_selector_children(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_complex_selector_children(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_complex_selector_childrens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_complex_selector_childrens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_complex_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_complex_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_component_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComponentValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_component_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_component_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComponentValue],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_component_values(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_component_values(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_compound_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_compound_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_compound_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_compound_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_compound_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_compound_selector_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_compound_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CompoundSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_compound_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_compound_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_condition(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_condition(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_query(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_query_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_query_and(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_query_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_query_not(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_query_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_query_or(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_query_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_query_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ContainerQueryType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_container_query_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_container_query_types(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_custom_highlight_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomHighlightName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_custom_highlight_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_custom_highlight_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_custom_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_custom_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_custom_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CustomIdent],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_custom_idents(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_custom_idents(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_custom_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_custom_media_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_custom_media_query(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQueryMediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_custom_media_query_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_custom_media_query_media_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_custom_property_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomPropertyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_custom_property_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_custom_property_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_dashed_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DashedIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_dashed_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_dashed_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_declaration<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Declaration,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_declaration(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_declaration(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_declaration_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_declaration_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_declaration_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationOrAtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_declaration_or_at_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_declaration_or_at_rule(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_delimiter<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Delimiter,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_delimiter(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_delimiter(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_delimiter_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DelimiterValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_delimiter_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_delimiter_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Dimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_dimension(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_dimension(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_dimension_token<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DimensionToken,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_dimension_token(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_dimension_token(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_document_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_document_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_document_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_document_prelude_matching_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_document_prelude_matching_function(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [DocumentPreludeMatchingFunction],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_document_prelude_matching_functions(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_document_prelude_matching_functions(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_extension_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExtensionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_extension_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_extension_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_family_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FamilyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_family_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_family_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_family_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [FamilyName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_family_names(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_family_names(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_flex(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_flex(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FontFeatureValuesPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_font_feature_values_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_font_feature_values_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_forgiving_complex_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_forgiving_complex_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_forgiving_complex_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_forgiving_complex_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_forgiving_relative_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_forgiving_relative_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_forgiving_relative_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_forgiving_relative_selector_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingRelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_forgiving_relative_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_forgiving_relative_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_forgiving_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_forgiving_selector_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_frequency<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Frequency,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_frequency(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_frequency(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_frequency_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FrequencyPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_frequency_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_frequency_percentage(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_function(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_function_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FunctionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_function_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_function_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_general_enclosed<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GeneralEnclosed,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_general_enclosed(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_general_enclosed(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_hex_color<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast HexColor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_hex_color(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_hex_color(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_hue(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_hue(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_id_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_id_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_id_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Ident],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_idents(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_idents(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportConditions,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_conditions(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_conditions(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_href<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportHref,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_href(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_href(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportLayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_layer_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_layer_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportantFlag,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_important_flag(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_important_flag(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_integer<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Integer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_integer(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_integer(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_keyframe_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_keyframe_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_keyframe_block(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_keyframe_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_keyframe_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_keyframe_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_keyframe_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [KeyframeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_keyframe_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_keyframe_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_keyframes_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_keyframes_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_keyframes_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_keyframes_pseudo_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_keyframes_pseudo_function(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoPrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_keyframes_pseudo_prefix(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_keyframes_pseudo_prefix(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_layer_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_layer_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_layer_name_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerNameList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_layer_name_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_layer_name_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_layer_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [LayerName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_layer_names(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_layer_names(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_layer_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_layer_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_layer_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_length(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_length(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_length_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LengthPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_length_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_length_percentage(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_list_of_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ListOfComponentValues,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_list_of_component_values(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_list_of_component_values(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_and(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_condition(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_condition(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_all_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionAllType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_condition_all_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_condition_all_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_all_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionAllType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_condition_all_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_condition_all_types(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_condition_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_condition_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_condition_without_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_condition_without_or(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOrType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_condition_without_or_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_condition_without_or_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionWithoutOrType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_condition_without_or_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_condition_without_or_types(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature_boolean(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature_boolean(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature_plain(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature_plain(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature_range(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature_range_comparison(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature_range_comparison(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature_range_interval(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature_range_interval(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_feature_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_feature_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_in_parens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_not(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_or(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_query(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQueryList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_query_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_query_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_querys<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaQuery],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_querys(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_querys(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_media_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_named_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_named_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_named_namespace(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Namespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_namespace(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_namespace_prefix(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_namespace_prefix(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_namespace_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_namespace_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_namespace_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePreludeUri,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_namespace_prelude_uri(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_namespace_prelude_uri(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NestingSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_nesting_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_nesting_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_number(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_number(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_number_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NumberType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_number_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_number_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_at_rule_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_at_rule_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_attribute_selector_matcher(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_attribute_selector_matcher(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_attribute_selector_modifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_attribute_selector_modifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_attribute_selector_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_attribute_selector_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Combinator>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_combinator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_combinator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ContainerName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_container_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_container_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ForgivingSelectorList>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_forgiving_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_forgiving_selector_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Function>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_function(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportConditions>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_import_conditions(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_import_conditions(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_import_layer_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_import_layer_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ImportantFlag>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_important_flag(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_important_flag(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_media_condition_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_media_condition_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_media_query_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_media_query_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<MediaType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_media_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Namespace>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_namespace(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NamespacePrefix>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_namespace_prefix(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_namespace_prefix(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NestingSelector>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_nesting_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_nesting_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_number<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Number>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_number(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_number(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_page_selector_pseudos(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_page_selector_pseudos(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<PageSelectorType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_page_selector_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_page_selector_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<SimpleBlock>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_simple_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_simple_block(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TypeSelector>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_type_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_type_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_url_modifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_url_modifiers(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<UrlValue>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_url_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_url_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_page_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_page_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_page_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_page_selector_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorPseudo,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_page_selector_pseudo(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_page_selector_pseudo(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelectorPseudo],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_page_selector_pseudos(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_page_selector_pseudos(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_page_selector_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_page_selector_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_page_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_page_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_page_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Percentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_percentage(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_pseudo_class_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_pseudo_class_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_pseudo_class_selector_children(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_pseudo_class_selector_children(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoClassSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_pseudo_class_selector_childrens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_pseudo_class_selector_childrens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_pseudo_element_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_pseudo_element_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_pseudo_element_selector_children(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_pseudo_element_selector_children(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoElementSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_pseudo_element_selector_childrens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_pseudo_element_selector_childrens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_qualified_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_qualified_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_qualified_rule(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_qualified_rule_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_qualified_rule_prelude(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_query_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QueryInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_query_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_query_in_parens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ratio(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ratio(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_relative_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_relative_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_relative_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_relative_selector_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [RelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_relative_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_relative_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_resolution<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Resolution,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_resolution(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_resolution(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_rule(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_rule(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_rules(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_rules(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_scope_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ScopeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_scope_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_scope_range(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_selector_list(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SequenceOfCustomIdents,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_sequence_of_custom_idents(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_sequence_of_custom_idents(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_simple_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_simple_block(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature_boolean(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature_boolean(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature_plain(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature_plain(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature_range(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature_range_comparison(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature_range_comparison(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature_range_interval(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature_range_interval(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_size_feature_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_size_feature_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_span(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_span(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_style_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StyleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_style_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_style_block(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_stylesheet<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Stylesheet,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_stylesheet(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_stylesheet(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_subclass_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SubclassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_subclass_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_subclass_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_subclass_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SubclassSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_subclass_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_subclass_selectors(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_and(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_condition(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_condition(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_condition_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_condition_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_condition_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SupportsConditionType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_condition_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_condition_types(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_feature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_in_parens(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_not(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_supports_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_supports_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_supports_or(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_tag_name_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TagNameSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_tag_name_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_tag_name_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_time(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_time(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_time_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TimePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_time_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_time_percentage(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_token(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_token(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_token_and_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TokenAndSpan,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_token_and_span(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_token_and_span(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TypeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_type_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_type_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_unicode_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnicodeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_unicode_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_unicode_range(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_universal_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UniversalSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_universal_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_universal_selector(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_unknown_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnknownDimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_unknown_dimension(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_unknown_dimension(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_url(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_url(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_url_key_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlKeyValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_url_key_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_url_key_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_url_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_url_modifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_url_modifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [UrlModifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_url_modifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_url_modifiers(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_url_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_url_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_url_value_raw<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValueRaw,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_url_value_raw(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_url_value_raw(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_wq_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WqName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_wq_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_wq_name(visitor, node, __ast_path)
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for ::swc_visit::Optional<V>
-where
-    V: VisitAstPath,
-{
-    #[inline]
-    fn visit_absolute_color_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AbsoluteColorBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_absolute_color_base(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_alpha_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AlphaValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_alpha_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_an_plus_b<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusB,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_an_plus_b(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnPlusBNotation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_an_plus_b_notation(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_angle(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_angle_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnglePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_angle_percentage(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_any_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AnyNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_any_namespace(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_at_rule(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_at_rule_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_at_rule_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AtRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_at_rule_prelude(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_atom(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_attribute_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcher,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_attribute_selector_matcher(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorMatcherValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_attribute_selector_matcher_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_attribute_selector_modifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AttributeSelectorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_attribute_selector_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_bin_op(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_operator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_operator_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcOperatorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_operator_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_product<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProduct,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_product(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcProductOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_product_or_operator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcProductOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_product_or_operators(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_sum<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcSum,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_sum(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CalcValueOrOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_value_or_operator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CalcValueOrOperator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_calc_value_or_operators(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_cmyk_component<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CmykComponent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_cmyk_component(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_color(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_color_profile_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ColorProfileName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_color_profile_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Combinator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_combinator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_combinator_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CombinatorValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_combinator_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_complex_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComplexSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_complex_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_complex_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_complex_selectors(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_component_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComponentValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_component_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ComponentValue],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_component_values(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_compound_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_compound_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_compound_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CompoundSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_compound_selector_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_compound_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CompoundSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_compound_selectors(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_condition(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_query(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_query_and(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_query_not(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_query_or(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContainerQueryType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_query_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_container_query_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ContainerQueryType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_container_query_types(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_custom_highlight_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomHighlightName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_custom_highlight_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_custom_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_custom_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [CustomIdent],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_custom_idents(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_custom_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_custom_media_query(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomMediaQueryMediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_custom_media_query_media_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_custom_property_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CustomPropertyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_custom_property_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_dashed_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DashedIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_dashed_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_declaration<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Declaration,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_declaration(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_declaration_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_declaration_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DeclarationOrAtRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_declaration_or_at_rule(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_delimiter<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Delimiter,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_delimiter(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_delimiter_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DelimiterValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_delimiter_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Dimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_dimension(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_dimension_token<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DimensionToken,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_dimension_token(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_document_prelude(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_document_prelude_matching_function(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [DocumentPreludeMatchingFunction],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_document_prelude_matching_functions(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_extension_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExtensionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_extension_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_family_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FamilyName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_family_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_family_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [FamilyName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_family_names(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_flex(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FontFeatureValuesPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_font_feature_values_prelude(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingComplexSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_forgiving_complex_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingComplexSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_forgiving_complex_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_forgiving_relative_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingRelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_forgiving_relative_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ForgivingRelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_forgiving_relative_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForgivingSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_forgiving_selector_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_frequency<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Frequency,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_frequency(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_frequency_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FrequencyPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_frequency_percentage(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_function(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_function_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FunctionName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_function_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_general_enclosed<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GeneralEnclosed,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_general_enclosed(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_hex_color<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast HexColor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_hex_color(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_hue(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_id_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_id_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Ident],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_idents(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportConditions,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_conditions(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_href<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportHref,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_href(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportLayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_layer_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_prelude(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportantFlag,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_important_flag(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_integer<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Integer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_integer(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_keyframe_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_keyframe_block(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_keyframe_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_keyframe_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_keyframe_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [KeyframeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_keyframe_selectors(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_keyframes_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_keyframes_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoFunction,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_keyframes_pseudo_function(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyframesPseudoPrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_keyframes_pseudo_prefix(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_layer_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_layer_name_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerNameList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_layer_name_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_layer_names<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [LayerName],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_layer_names(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_layer_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LayerPrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_layer_prelude(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_length(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_length_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LengthPercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_length_percentage(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_list_of_component_values<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ListOfComponentValues,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_list_of_component_values(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_and(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_condition(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_all_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionAllType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_condition_all_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_all_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionAllType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_condition_all_types(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_condition_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_condition_without_or(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaConditionWithoutOrType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_condition_without_or_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaConditionWithoutOrType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_condition_without_or_types(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature_boolean(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature_plain(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature_range(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature_range_comparison(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature_range_interval(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_feature_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_in_parens(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_not(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_or(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_query(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaQueryList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_query_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_querys<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [MediaQuery],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_querys(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MediaType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_media_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_named_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedNamespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_named_namespace(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Namespace,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_namespace(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrefix,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_namespace_prefix(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_namespace_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_namespace_prelude(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamespacePreludeUri,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_namespace_prelude_uri(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NestingSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_nesting_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_number(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_number_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NumberType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_number_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_at_rule_prelude(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_atom(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_attribute_selector_matcher(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_attribute_selector_modifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<AttributeSelectorValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_attribute_selector_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_combinator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Combinator>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_combinator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_container_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ContainerName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_container_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ForgivingSelectorList>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_forgiving_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Function>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_function(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_import_conditions<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportConditions>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_import_conditions(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_import_layer_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_important_flag<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ImportantFlag>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_important_flag(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_media_condition_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_media_query_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_media_query_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_media_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<MediaType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_media_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Namespace>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_namespace(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NamespacePrefix>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_namespace_prefix(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<NestingSelector>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_nesting_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_number<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Number>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_number(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_page_selector_pseudos(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<PageSelectorType>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_page_selector_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<SimpleBlock>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_simple_block(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TypeSelector>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_type_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_url_modifiers(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<UrlValue>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_url_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_page_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_page_selector_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorPseudo,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_page_selector_pseudo(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelectorPseudo],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_page_selector_pseudos(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_page_selector_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PageSelectorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_page_selector_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_page_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PageSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_page_selectors(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Percentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_percentage(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pseudo_class_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoClassSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pseudo_class_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoClassSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pseudo_class_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pseudo_element_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PseudoElementSelectorChildren,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pseudo_element_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PseudoElementSelectorChildren],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pseudo_element_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_qualified_rule<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRule,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_qualified_rule(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QualifiedRulePrelude,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_qualified_rule_prelude(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_query_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast QueryInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_query_in_parens(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ratio(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_relative_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RelativeSelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_relative_selector_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [RelativeSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_relative_selectors(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_resolution<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Resolution,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_resolution(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_rule(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_rules(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_scope_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ScopeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_scope_range(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_selector_list<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SelectorList,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_selector_list(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SequenceOfCustomIdents,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_sequence_of_custom_idents(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_simple_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_simple_block(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_boolean<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureBoolean,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature_boolean(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_plain<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeaturePlain,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature_plain(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature_range(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeComparison,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature_range_comparison(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureRangeInterval,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature_range_interval(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_size_feature_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SizeFeatureValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_size_feature_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_span(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_str(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_style_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StyleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_style_block(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_stylesheet<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Stylesheet,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_stylesheet(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_subclass_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SubclassSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_subclass_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_subclass_selectors<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SubclassSelector],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_subclass_selectors(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_and<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsAnd,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_and(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_condition<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsCondition,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_condition(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_condition_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsConditionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_condition_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_condition_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SupportsConditionType],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_condition_types(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_feature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsFeature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_feature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_in_parens<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsInParens,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_in_parens(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_not<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsNot,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_not(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_supports_or<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SupportsOr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_supports_or(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_tag_name_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TagNameSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_tag_name_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_time(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_time_percentage<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TimePercentage,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_time_percentage(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_token(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_token_and_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TokenAndSpan,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_token_and_span(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_type_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TypeSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_type_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_unicode_range<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnicodeRange,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_unicode_range(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_universal_selector<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UniversalSelector,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_universal_selector(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_unknown_dimension<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnknownDimension,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_unknown_dimension(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_url(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_url_key_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlKeyValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_url_key_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_url_modifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlModifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_url_modifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_url_modifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [UrlModifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_url_modifiers(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_url_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_url_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_url_value_raw<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UrlValueRaw,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_url_value_raw(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_wq_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WqName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_wq_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for ::swc_visit::All<V> where V: VisitAll {}
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitWithAstPath<V: ?Sized + VisitAstPath> {
+pub trait VisitWith<V: ?Sized + Visit> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    );
+    fn visit_with(&self, visitor: &mut V);
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    );
+    fn visit_children_with(&self, visitor: &mut V);
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AbsoluteColorBase {
-    #[doc = "Calls [VisitAstPath`::visit_absolute_color_base`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_absolute_color_base(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AbsoluteColorBase {
+    #[doc = "Calls [Visit`::visit_absolute_color_base`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_absolute_color_base(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AbsoluteColorBase::HexColor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AbsoluteColorBase(
-                    self,
-                    self::fields::AbsoluteColorBaseField::HexColor,
-                ));
-                <HexColor as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <HexColor as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AbsoluteColorBase(
-                    self,
-                    self::fields::AbsoluteColorBaseField::NamedColorOrTransparent,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AbsoluteColorBase::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AbsoluteColorBase(
-                    self,
-                    self::fields::AbsoluteColorBaseField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AlphaValue {
-    #[doc = "Calls [VisitAstPath`::visit_alpha_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_alpha_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AlphaValue {
+    #[doc = "Calls [Visit`::visit_alpha_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_alpha_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AlphaValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AlphaValue(
-                    self,
-                    self::fields::AlphaValueField::Number,
-                ));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AlphaValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AlphaValue(
-                    self,
-                    self::fields::AlphaValueField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnPlusB {
-    #[doc = "Calls [VisitAstPath`::visit_an_plus_b`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_an_plus_b(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AnPlusB {
+    #[doc = "Calls [Visit`::visit_an_plus_b`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_an_plus_b(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AnPlusB::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusB(
-                    self,
-                    self::fields::AnPlusBField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AnPlusB::AnPlusBNotation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusB(
-                    self,
-                    self::fields::AnPlusBField::AnPlusBNotation,
-                ));
-                <AnPlusBNotation as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AnPlusBNotation as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnPlusBNotation {
-    #[doc = "Calls [VisitAstPath`::visit_an_plus_b_notation`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_an_plus_b_notation(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AnPlusBNotation {
+    #[doc = "Calls [Visit`::visit_an_plus_b_notation`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_an_plus_b_notation(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AnPlusBNotation {
                 span,
@@ -27518,192 +7897,80 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnPlusBNotation {
                 b_raw,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusBNotation(
-                        self,
-                        self::fields::AnPlusBNotationField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusBNotation(
-                        self,
-                        self::fields::AnPlusBNotationField::ARaw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        a_raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(a_raw, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusBNotation(
-                        self,
-                        self::fields::AnPlusBNotationField::BRaw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        b_raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(b_raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Angle {
-    #[doc = "Calls [VisitAstPath`::visit_angle`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_angle(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Angle {
+    #[doc = "Calls [Visit`::visit_angle`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_angle(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Angle { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Angle(
-                        self,
-                        self::fields::AngleField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Angle(
-                        self,
-                        self::fields::AngleField::Value,
-                    ));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Angle(
-                        self,
-                        self::fields::AngleField::Unit,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnglePercentage {
-    #[doc = "Calls [VisitAstPath`::visit_angle_percentage`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_angle_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AnglePercentage {
+    #[doc = "Calls [Visit`::visit_angle_percentage`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_angle_percentage(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AnglePercentage::Angle { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnglePercentage(
-                    self,
-                    self::fields::AnglePercentageField::Angle,
-                ));
-                <Angle as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Angle as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AnglePercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnglePercentage(
-                    self,
-                    self::fields::AnglePercentageField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnyNamespace {
-    #[doc = "Calls [VisitAstPath`::visit_any_namespace`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_any_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AnyNamespace {
+    #[doc = "Calls [Visit`::visit_any_namespace`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_any_namespace(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AnyNamespace { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnyNamespace(
-                        self,
-                        self::fields::AnyNamespaceField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AtRule {
-    #[doc = "Calls [VisitAstPath`::visit_at_rule`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AtRule {
+    #[doc = "Calls [Visit`::visit_at_rule`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_at_rule(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AtRule {
                 span,
@@ -27712,343 +7979,113 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AtRule {
                 block,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
-                        self,
-                        self::fields::AtRuleField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
-                        self,
-                        self::fields::AtRuleField::Name,
-                    ));
-                    <AtRuleName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <AtRuleName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
-                        self,
-                        self::fields::AtRuleField::Prelude,
-                    ));
-                    <Option<Box<AtRulePrelude>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<AtRulePrelude>> as VisitWith<V>>::visit_with(prelude, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
-                        self,
-                        self::fields::AtRuleField::Block,
-                    ));
-                    <Option<SimpleBlock> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<SimpleBlock> as VisitWith<V>>::visit_with(block, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AtRuleName {
-    #[doc = "Calls [VisitAstPath`::visit_at_rule_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AtRuleName {
+    #[doc = "Calls [Visit`::visit_at_rule_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_at_rule_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AtRuleName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRuleName(
-                    self,
-                    self::fields::AtRuleNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRuleName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRuleName(
-                    self,
-                    self::fields::AtRuleNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AtRulePrelude {
-    #[doc = "Calls [VisitAstPath`::visit_at_rule_prelude`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_at_rule_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AtRulePrelude {
+    #[doc = "Calls [Visit`::visit_at_rule_prelude`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_at_rule_prelude(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AtRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::ListOfComponentValues,
-                ));
-                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::CharsetPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::CharsetPrelude,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::PropertyPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::PropertyPrelude,
-                ));
-                <CustomPropertyName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomPropertyName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::CounterStylePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::CounterStylePrelude,
-                ));
-                <CustomIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::ColorProfilePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::ColorProfilePrelude,
-                ));
-                <ColorProfileName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ColorProfileName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::DocumentPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::DocumentPrelude,
-                ));
-                <DocumentPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DocumentPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::FontPaletteValuesPrelude,
-                ));
-                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::FontFeatureValuesPrelude,
-                ));
-                <FontFeatureValuesPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FontFeatureValuesPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::NestPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::NestPrelude,
-                ));
-                <SelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::KeyframesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::KeyframesPrelude,
-                ));
-                <KeyframesName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <KeyframesName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::ImportPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::ImportPrelude,
-                ));
-                <ImportPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::NamespacePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::NamespacePrelude,
-                ));
-                <NamespacePrelude as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NamespacePrelude as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::MediaPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::MediaPrelude,
-                ));
-                <MediaQueryList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaQueryList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::SupportsPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::SupportsPrelude,
-                ));
-                <SupportsCondition as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            AtRulePrelude::PagePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::PagePrelude,
-                ));
-                <PageSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            AtRulePrelude::LayerPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::LayerPrelude,
-                ));
-                <LayerPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsCondition as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            AtRulePrelude::PagePrelude { 0: _field_0 } => {
+                <PageSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            AtRulePrelude::LayerPrelude { 0: _field_0 } => {
+                <LayerPrelude as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::ContainerPrelude,
-                ));
-                <ContainerCondition as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContainerCondition as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::CustomMediaPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::CustomMediaPrelude,
-                ));
-                <CustomMediaQuery as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomMediaQuery as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AtRulePrelude::ScopePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
-                    self,
-                    self::fields::AtRulePreludeField::ScopePrelude,
-                ));
-                <ScopeRange as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ScopeRange as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelector {
-    #[doc = "Calls [VisitAstPath`::visit_attribute_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelector {
+    #[doc = "Calls [Visit`::visit_attribute_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_attribute_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AttributeSelector {
                 span,
@@ -28058,133 +8095,52 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelector {
                 modifier,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
-                            self,
-                            self::fields::AttributeSelectorField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
-                            self,
-                            self::fields::AttributeSelectorField::Name,
-                        ));
-                    <WqName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <WqName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
-                            self,
-                            self::fields::AttributeSelectorField::Matcher,
-                        ));
-                    <Option<AttributeSelectorMatcher> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        matcher,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<AttributeSelectorMatcher> as VisitWith<V>>::visit_with(matcher, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
-                            self,
-                            self::fields::AttributeSelectorField::Value,
-                        ));
-                    <Option<AttributeSelectorValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<AttributeSelectorValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
-                            self,
-                            self::fields::AttributeSelectorField::Modifier,
-                        ));
-                    <Option<AttributeSelectorModifier> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        modifier,
-                        visitor,
-                        &mut *__ast_path,
+                    <Option<AttributeSelectorModifier> as VisitWith<V>>::visit_with(
+                        modifier, visitor,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorMatcher {
-    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_matcher`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_matcher(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorMatcher {
+    #[doc = "Calls [Visit`::visit_attribute_selector_matcher`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_attribute_selector_matcher(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AttributeSelectorMatcher { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorMatcher(
-                            self,
-                            self::fields::AttributeSelectorMatcherField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorMatcher(
-                            self,
-                            self::fields::AttributeSelectorMatcherField::Value,
-                        ));
-                    <AttributeSelectorMatcherValue as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <AttributeSelectorMatcherValue as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorMatcherValue {
-    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_matcher_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_matcher_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorMatcherValue {
+    #[doc = "Calls [Visit`::visit_attribute_selector_matcher_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_attribute_selector_matcher_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AttributeSelectorMatcherValue::Equals => {}
             AttributeSelectorMatcherValue::Tilde => {}
@@ -28195,115 +8151,49 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorMatcherV
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorModifier {
-    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_modifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_modifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorModifier {
+    #[doc = "Calls [Visit`::visit_attribute_selector_modifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_attribute_selector_modifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AttributeSelectorModifier { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorModifier(
-                            self,
-                            self::fields::AttributeSelectorModifierField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorModifier(
-                            self,
-                            self::fields::AttributeSelectorModifierField::Value,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorValue {
-    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_attribute_selector_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AttributeSelectorValue {
+    #[doc = "Calls [Visit`::visit_attribute_selector_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_attribute_selector_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AttributeSelectorValue::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::AttributeSelectorValue(
-                        self,
-                        self::fields::AttributeSelectorValueField::Str,
-                    ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AttributeSelectorValue::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::AttributeSelectorValue(
-                        self,
-                        self::fields::AttributeSelectorValueField::Ident,
-                    ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinOp {
-    #[doc = "Calls [VisitAstPath`::visit_bin_op`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_bin_op(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BinOp {
+    #[doc = "Calls [Visit`::visit_bin_op`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_bin_op(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BinOp::Add => {}
             BinOp::Sub => {}
@@ -28312,68 +8202,32 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcOperator {
-    #[doc = "Calls [VisitAstPath`::visit_calc_operator`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CalcOperator {
+    #[doc = "Calls [Visit`::visit_calc_operator`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_operator(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CalcOperator { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcOperator(
-                        self,
-                        self::fields::CalcOperatorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcOperator(
-                        self,
-                        self::fields::CalcOperatorField::Value,
-                    ));
-                    <CalcOperatorType as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <CalcOperatorType as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcOperatorType {
-    #[doc = "Calls [VisitAstPath`::visit_calc_operator_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_operator_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CalcOperatorType {
+    #[doc = "Calls [Visit`::visit_calc_operator_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_operator_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CalcOperatorType::Add => {}
             CalcOperatorType::Sub => {}
@@ -28382,529 +8236,209 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcOperatorType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcProduct {
-    #[doc = "Calls [VisitAstPath`::visit_calc_product`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CalcProduct {
+    #[doc = "Calls [Visit`::visit_calc_product`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_product(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CalcProduct { span, expressions } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcProduct(
-                        self,
-                        self::fields::CalcProductField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcProduct(
-                        self,
-                        self::fields::CalcProductField::Expressions(usize::MAX),
-                    ));
-                    <Vec<CalcValueOrOperator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expressions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<CalcValueOrOperator> as VisitWith<V>>::visit_with(expressions, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcProductOrOperator {
-    #[doc = "Calls [VisitAstPath`::visit_calc_product_or_operator`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product_or_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CalcProductOrOperator {
+    #[doc = "Calls [Visit`::visit_calc_product_or_operator`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_product_or_operator(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CalcProductOrOperator::Product { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::CalcProductOrOperator(
-                        self,
-                        self::fields::CalcProductOrOperatorField::Product,
-                    ));
-                <CalcProduct as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcProduct as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CalcProductOrOperator::Operator { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::CalcProductOrOperator(
-                        self,
-                        self::fields::CalcProductOrOperatorField::Operator,
-                    ));
-                <CalcOperator as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcOperator as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcSum {
-    #[doc = "Calls [VisitAstPath`::visit_calc_sum`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_sum(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CalcSum {
+    #[doc = "Calls [Visit`::visit_calc_sum`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_sum(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CalcSum { span, expressions } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcSum(
-                        self,
-                        self::fields::CalcSumField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcSum(
-                        self,
-                        self::fields::CalcSumField::Expressions(usize::MAX),
-                    ));
-                    <Vec<CalcProductOrOperator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expressions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<CalcProductOrOperator> as VisitWith<V>>::visit_with(expressions, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcValue {
-    #[doc = "Calls [VisitAstPath`::visit_calc_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CalcValue {
+    #[doc = "Calls [Visit`::visit_calc_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            CalcValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
-                    self,
-                    self::fields::CalcValueField::Number,
-                ));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            CalcValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
-                    self,
-                    self::fields::CalcValueField::Dimension,
-                ));
-                <Dimension as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            CalcValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
-                    self,
-                    self::fields::CalcValueField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            CalcValue::Number { 0: _field_0 } => {
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            CalcValue::Dimension { 0: _field_0 } => {
+                <Dimension as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            CalcValue::Percentage { 0: _field_0 } => {
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CalcValue::Constant { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
-                    self,
-                    self::fields::CalcValueField::Constant,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CalcValue::Sum { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
-                    self,
-                    self::fields::CalcValueField::Sum,
-                ));
-                <CalcSum as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcSum as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CalcValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
-                    self,
-                    self::fields::CalcValueField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcValueOrOperator {
-    #[doc = "Calls [VisitAstPath`::visit_calc_value_or_operator`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value_or_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CalcValueOrOperator {
+    #[doc = "Calls [Visit`::visit_calc_value_or_operator`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_value_or_operator(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CalcValueOrOperator::Value { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValueOrOperator(
-                    self,
-                    self::fields::CalcValueOrOperatorField::Value,
-                ));
-                <CalcValue as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcValue as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CalcValueOrOperator::Operator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValueOrOperator(
-                    self,
-                    self::fields::CalcValueOrOperatorField::Operator,
-                ));
-                <CalcOperator as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcOperator as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassSelector {
-    #[doc = "Calls [VisitAstPath`::visit_class_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ClassSelector {
+    #[doc = "Calls [Visit`::visit_class_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ClassSelector { span, text } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassSelector(
-                        self,
-                        self::fields::ClassSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassSelector(
-                        self,
-                        self::fields::ClassSelectorField::Text,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        text,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(text, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CmykComponent {
-    #[doc = "Calls [VisitAstPath`::visit_cmyk_component`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_cmyk_component(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CmykComponent {
+    #[doc = "Calls [Visit`::visit_cmyk_component`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_cmyk_component(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CmykComponent::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CmykComponent(
-                    self,
-                    self::fields::CmykComponentField::Number,
-                ));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CmykComponent::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CmykComponent(
-                    self,
-                    self::fields::CmykComponentField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CmykComponent::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CmykComponent(
-                    self,
-                    self::fields::CmykComponentField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Color {
-    #[doc = "Calls [VisitAstPath`::visit_color`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_color(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Color {
+    #[doc = "Calls [Visit`::visit_color`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_color(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Color::AbsoluteColorBase { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Color(
-                    self,
-                    self::fields::ColorField::AbsoluteColorBase,
-                ));
-                <AbsoluteColorBase as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AbsoluteColorBase as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Color::CurrentColorOrSystemColor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Color(
-                    self,
-                    self::fields::ColorField::CurrentColorOrSystemColor,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Color::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Color(
-                    self,
-                    self::fields::ColorField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ColorProfileName {
-    #[doc = "Calls [VisitAstPath`::visit_color_profile_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_color_profile_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ColorProfileName {
+    #[doc = "Calls [Visit`::visit_color_profile_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_color_profile_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ColorProfileName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ColorProfileName(
-                    self,
-                    self::fields::ColorProfileNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ColorProfileName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ColorProfileName(
-                    self,
-                    self::fields::ColorProfileNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Combinator {
-    #[doc = "Calls [VisitAstPath`::visit_combinator`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_combinator(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Combinator {
+    #[doc = "Calls [Visit`::visit_combinator`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_combinator(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Combinator { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Combinator(
-                        self,
-                        self::fields::CombinatorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Combinator(
-                        self,
-                        self::fields::CombinatorField::Value,
-                    ));
-                    <CombinatorValue as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <CombinatorValue as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CombinatorValue {
-    #[doc = "Calls [VisitAstPath`::visit_combinator_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_combinator_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CombinatorValue {
+    #[doc = "Calls [Visit`::visit_combinator_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_combinator_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CombinatorValue::Descendant => {}
             CombinatorValue::NextSibling => {}
@@ -28914,486 +8448,156 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CombinatorValue {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComplexSelector {
-    #[doc = "Calls [VisitAstPath`::visit_complex_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ComplexSelector {
+    #[doc = "Calls [Visit`::visit_complex_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_complex_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ComplexSelector { span, children } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComplexSelector(
-                        self,
-                        self::fields::ComplexSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComplexSelector(
-                        self,
-                        self::fields::ComplexSelectorField::Children(usize::MAX),
-                    ));
-                    <Vec<ComplexSelectorChildren> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComplexSelectorChildren> as VisitWith<V>>::visit_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComplexSelectorChildren {
-    #[doc = "Calls [VisitAstPath`::visit_complex_selector_children`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ComplexSelectorChildren {
+    #[doc = "Calls [Visit`::visit_complex_selector_children`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_complex_selector_children(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ComplexSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::ComplexSelectorChildren(
-                        self,
-                        self::fields::ComplexSelectorChildrenField::CompoundSelector,
-                    ));
-                <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComplexSelectorChildren::Combinator { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::ComplexSelectorChildren(
-                        self,
-                        self::fields::ComplexSelectorChildrenField::Combinator,
-                    ));
-                <Combinator as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Combinator as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComponentValue {
-    #[doc = "Calls [VisitAstPath`::visit_component_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_component_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ComponentValue {
+    #[doc = "Calls [Visit`::visit_component_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_component_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ComponentValue::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::PreservedToken,
-                ));
-                <Box<TokenAndSpan> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TokenAndSpan> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Function,
-                ));
-                <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Function> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::SimpleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::SimpleBlock,
-                ));
-                <Box<SimpleBlock> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<SimpleBlock> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::AtRule,
-                ));
-                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::QualifiedRule,
-                ));
-                <Box<QualifiedRule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<QualifiedRule> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::KeyframeBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::KeyframeBlock,
-                ));
-                <Box<KeyframeBlock> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            ComponentValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Ident,
-                ));
-                <Box<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<KeyframeBlock> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
-            ComponentValue::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::DashedIdent,
-                ));
-                <Box<DashedIdent> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+            ComponentValue::Ident { 0: _field_0 } => {
+                <Box<Ident> as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            ComponentValue::DashedIdent { 0: _field_0 } => {
+                <Box<DashedIdent> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Str,
-                ));
-                <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Str> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Url,
-                ));
-                <Box<Url> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Url> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Integer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Integer,
-                ));
-                <Box<Integer> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Integer> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Number,
-                ));
-                <Box<Number> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Number> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Percentage,
-                ));
-                <Box<Percentage> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Percentage> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Dimension,
-                ));
-                <Box<Dimension> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Dimension> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::LengthPercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::LengthPercentage,
-                ));
-                <Box<LengthPercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<LengthPercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::FrequencyPercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::FrequencyPercentage,
-                ));
-                <Box<FrequencyPercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<FrequencyPercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::AnglePercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::AnglePercentage,
-                ));
-                <Box<AnglePercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AnglePercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::TimePercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::TimePercentage,
-                ));
-                <Box<TimePercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TimePercentage> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Ratio,
-                ));
-                <Box<Ratio> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Ratio> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::UnicodeRange { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::UnicodeRange,
-                ));
-                <Box<UnicodeRange> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<UnicodeRange> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Color { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Color,
-                ));
-                <Box<Color> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Color> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::AlphaValue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::AlphaValue,
-                ));
-                <Box<AlphaValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AlphaValue> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Hue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Hue,
-                ));
-                <Box<Hue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Hue> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::CmykComponent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::CmykComponent,
-                ));
-                <Box<CmykComponent> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<CmykComponent> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Delimiter { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Delimiter,
-                ));
-                <Box<Delimiter> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Delimiter> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::CalcSum { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::CalcSum,
-                ));
-                <Box<CalcSum> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<CalcSum> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::ComplexSelector,
-                ));
-                <Box<ComplexSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ComplexSelector> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::LayerName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::LayerName,
-                ));
-                <Box<LayerName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<LayerName> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::SupportsCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::SupportsCondition,
-                ));
-                <Box<SupportsCondition> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<SupportsCondition> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::Declaration,
-                ));
-                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ComponentValue::IdSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
-                    self,
-                    self::fields::ComponentValueField::IdSelector,
-                ));
-                <Box<IdSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<IdSelector> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CompoundSelector {
-    #[doc = "Calls [VisitAstPath`::visit_compound_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CompoundSelector {
+    #[doc = "Calls [Visit`::visit_compound_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_compound_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CompoundSelector {
                 span,
@@ -29402,253 +8606,102 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CompoundSelector {
                 subclass_selectors,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
-                        self,
-                        self::fields::CompoundSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
-                        self,
-                        self::fields::CompoundSelectorField::NestingSelector,
-                    ));
-                    <Option<NestingSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        nesting_selector,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<NestingSelector> as VisitWith<V>>::visit_with(nesting_selector, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
-                        self,
-                        self::fields::CompoundSelectorField::TypeSelector,
-                    ));
-                    <Option<Box<TypeSelector>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_selector,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TypeSelector>> as VisitWith<V>>::visit_with(type_selector, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
-                        self,
-                        self::fields::CompoundSelectorField::SubclassSelectors(usize::MAX),
-                    ));
-                    <Vec<SubclassSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        subclass_selectors,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<SubclassSelector> as VisitWith<V>>::visit_with(subclass_selectors, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CompoundSelectorList {
-    #[doc = "Calls [VisitAstPath`::visit_compound_selector_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CompoundSelectorList {
+    #[doc = "Calls [Visit`::visit_compound_selector_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_compound_selector_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CompoundSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CompoundSelectorList(
-                            self,
-                            self::fields::CompoundSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CompoundSelectorList(
-                            self,
-                            self::fields::CompoundSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<CompoundSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<CompoundSelector> as VisitWith<V>>::visit_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerCondition {
-    #[doc = "Calls [VisitAstPath`::visit_container_condition`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_condition(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContainerCondition {
+    #[doc = "Calls [Visit`::visit_container_condition`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_condition(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContainerCondition { span, name, query } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerCondition(
-                            self,
-                            self::fields::ContainerConditionField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerCondition(
-                            self,
-                            self::fields::ContainerConditionField::Name,
-                        ));
-                    <Option<ContainerName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ContainerName> as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerCondition(
-                            self,
-                            self::fields::ContainerConditionField::Query,
-                        ));
-                    <ContainerQuery as VisitWithAstPath<V>>::visit_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ContainerQuery as VisitWith<V>>::visit_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerName {
-    #[doc = "Calls [VisitAstPath`::visit_container_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContainerName {
+    #[doc = "Calls [Visit`::visit_container_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContainerName::CustomIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerName(
-                    self,
-                    self::fields::ContainerNameField::CustomIdent,
-                ));
-                <CustomIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQuery {
-    #[doc = "Calls [VisitAstPath`::visit_container_query`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContainerQuery {
+    #[doc = "Calls [Visit`::visit_container_query`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_query(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContainerQuery { span, queries } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQuery(
-                        self,
-                        self::fields::ContainerQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQuery(
-                        self,
-                        self::fields::ContainerQueryField::Queries(usize::MAX),
-                    ));
-                    <Vec<ContainerQueryType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        queries,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ContainerQueryType> as VisitWith<V>>::visit_with(queries, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryAnd {
-    #[doc = "Calls [VisitAstPath`::visit_container_query_and`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_and(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryAnd {
+    #[doc = "Calls [Visit`::visit_container_query_and`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_query_and(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContainerQueryAnd {
                 span,
@@ -29656,62 +8709,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryAnd {
                 query,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryAnd(
-                            self,
-                            self::fields::ContainerQueryAndField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryAnd(
-                            self,
-                            self::fields::ContainerQueryAndField::Keyword,
-                        ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryAnd(
-                            self,
-                            self::fields::ContainerQueryAndField::Query,
-                        ));
-                    <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QueryInParens as VisitWith<V>>::visit_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryNot {
-    #[doc = "Calls [VisitAstPath`::visit_container_query_not`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_not(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryNot {
+    #[doc = "Calls [Visit`::visit_container_query_not`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_query_not(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContainerQueryNot {
                 span,
@@ -29719,62 +8735,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryNot {
                 query,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryNot(
-                            self,
-                            self::fields::ContainerQueryNotField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryNot(
-                            self,
-                            self::fields::ContainerQueryNotField::Keyword,
-                        ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryNot(
-                            self,
-                            self::fields::ContainerQueryNotField::Query,
-                        ));
-                    <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QueryInParens as VisitWith<V>>::visit_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryOr {
-    #[doc = "Calls [VisitAstPath`::visit_container_query_or`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_or(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryOr {
+    #[doc = "Calls [Visit`::visit_container_query_or`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_query_or(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContainerQueryOr {
                 span,
@@ -29782,455 +8761,175 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryOr {
                 query,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryOr(
-                        self,
-                        self::fields::ContainerQueryOrField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryOr(
-                        self,
-                        self::fields::ContainerQueryOrField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryOr(
-                        self,
-                        self::fields::ContainerQueryOrField::Query,
-                    ));
-                    <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QueryInParens as VisitWith<V>>::visit_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryType {
-    #[doc = "Calls [VisitAstPath`::visit_container_query_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContainerQueryType {
+    #[doc = "Calls [Visit`::visit_container_query_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_query_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContainerQueryType::Not { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
-                    self,
-                    self::fields::ContainerQueryTypeField::Not,
-                ));
-                <ContainerQueryNot as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContainerQueryNot as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ContainerQueryType::And { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
-                    self,
-                    self::fields::ContainerQueryTypeField::And,
-                ));
-                <ContainerQueryAnd as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContainerQueryAnd as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ContainerQueryType::Or { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
-                    self,
-                    self::fields::ContainerQueryTypeField::Or,
-                ));
-                <ContainerQueryOr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContainerQueryOr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ContainerQueryType::QueryInParens { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
-                    self,
-                    self::fields::ContainerQueryTypeField::QueryInParens,
-                ));
-                <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <QueryInParens as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomHighlightName {
-    #[doc = "Calls [VisitAstPath`::visit_custom_highlight_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_highlight_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CustomHighlightName {
+    #[doc = "Calls [Visit`::visit_custom_highlight_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_custom_highlight_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CustomHighlightName { span, value, raw } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CustomHighlightName(
-                            self,
-                            self::fields::CustomHighlightNameField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CustomHighlightName(
-                            self,
-                            self::fields::CustomHighlightNameField::Value,
-                        ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CustomHighlightName(
-                            self,
-                            self::fields::CustomHighlightNameField::Raw,
-                        ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomIdent {
-    #[doc = "Calls [VisitAstPath`::visit_custom_ident`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CustomIdent {
+    #[doc = "Calls [Visit`::visit_custom_ident`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_custom_ident(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CustomIdent { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomIdent(
-                        self,
-                        self::fields::CustomIdentField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomIdent(
-                        self,
-                        self::fields::CustomIdentField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomIdent(
-                        self,
-                        self::fields::CustomIdentField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomMediaQuery {
-    #[doc = "Calls [VisitAstPath`::visit_custom_media_query`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_media_query(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CustomMediaQuery {
+    #[doc = "Calls [Visit`::visit_custom_media_query`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_custom_media_query(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CustomMediaQuery { span, name, media } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomMediaQuery(
-                        self,
-                        self::fields::CustomMediaQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomMediaQuery(
-                        self,
-                        self::fields::CustomMediaQueryField::Name,
-                    ));
-                    <ExtensionName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ExtensionName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomMediaQuery(
-                        self,
-                        self::fields::CustomMediaQueryField::Media,
-                    ));
-                    <CustomMediaQueryMediaType as VisitWithAstPath<V>>::visit_with_ast_path(
-                        media,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <CustomMediaQueryMediaType as VisitWith<V>>::visit_with(media, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomMediaQueryMediaType {
-    #[doc = "Calls [VisitAstPath`::visit_custom_media_query_media_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_media_query_media_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CustomMediaQueryMediaType {
+    #[doc = "Calls [Visit`::visit_custom_media_query_media_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_custom_media_query_media_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CustomMediaQueryMediaType::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::CustomMediaQueryMediaType(
-                        self,
-                        self::fields::CustomMediaQueryMediaTypeField::Ident,
-                    ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::CustomMediaQueryMediaType(
-                        self,
-                        self::fields::CustomMediaQueryMediaTypeField::MediaQueryList,
-                    ));
-                <MediaQueryList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaQueryList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomPropertyName {
-    #[doc = "Calls [VisitAstPath`::visit_custom_property_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_property_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CustomPropertyName {
+    #[doc = "Calls [Visit`::visit_custom_property_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_custom_property_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CustomPropertyName { span, value, raw } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CustomPropertyName(
-                            self,
-                            self::fields::CustomPropertyNameField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CustomPropertyName(
-                            self,
-                            self::fields::CustomPropertyNameField::Value,
-                        ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::CustomPropertyName(
-                            self,
-                            self::fields::CustomPropertyNameField::Raw,
-                        ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DashedIdent {
-    #[doc = "Calls [VisitAstPath`::visit_dashed_ident`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dashed_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DashedIdent {
+    #[doc = "Calls [Visit`::visit_dashed_ident`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_dashed_ident(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DashedIdent { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DashedIdent(
-                        self,
-                        self::fields::DashedIdentField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DashedIdent(
-                        self,
-                        self::fields::DashedIdentField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DashedIdent(
-                        self,
-                        self::fields::DashedIdentField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Declaration {
-    #[doc = "Calls [VisitAstPath`::visit_declaration`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Declaration {
+    #[doc = "Calls [Visit`::visit_declaration`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_declaration(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Declaration {
                 span,
@@ -30239,212 +8938,84 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Declaration {
                 important,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
-                        self,
-                        self::fields::DeclarationField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
-                        self,
-                        self::fields::DeclarationField::Name,
-                    ));
-                    <DeclarationName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <DeclarationName as VisitWith<V>>::visit_with(name, visitor)
                 };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
-                        self,
-                        self::fields::DeclarationField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                {
+                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
-                        self,
-                        self::fields::DeclarationField::Important,
-                    ));
-                    <Option<ImportantFlag> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        important,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ImportantFlag> as VisitWith<V>>::visit_with(important, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DeclarationName {
-    #[doc = "Calls [VisitAstPath`::visit_declaration_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DeclarationName {
+    #[doc = "Calls [Visit`::visit_declaration_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_declaration_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DeclarationName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationName(
-                    self,
-                    self::fields::DeclarationNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             DeclarationName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationName(
-                    self,
-                    self::fields::DeclarationNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DeclarationOrAtRule {
-    #[doc = "Calls [VisitAstPath`::visit_declaration_or_at_rule`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_declaration_or_at_rule(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DeclarationOrAtRule {
+    #[doc = "Calls [Visit`::visit_declaration_or_at_rule`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_declaration_or_at_rule(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DeclarationOrAtRule::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationOrAtRule(
-                    self,
-                    self::fields::DeclarationOrAtRuleField::Declaration,
-                ));
-                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             DeclarationOrAtRule::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationOrAtRule(
-                    self,
-                    self::fields::DeclarationOrAtRuleField::AtRule,
-                ));
-                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationOrAtRule(
-                    self,
-                    self::fields::DeclarationOrAtRuleField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Delimiter {
-    #[doc = "Calls [VisitAstPath`::visit_delimiter`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_delimiter(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Delimiter {
+    #[doc = "Calls [Visit`::visit_delimiter`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_delimiter(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Delimiter { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Delimiter(
-                        self,
-                        self::fields::DelimiterField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Delimiter(
-                        self,
-                        self::fields::DelimiterField::Value,
-                    ));
-                    <DelimiterValue as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <DelimiterValue as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DelimiterValue {
-    #[doc = "Calls [VisitAstPath`::visit_delimiter_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_delimiter_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DelimiterValue {
+    #[doc = "Calls [Visit`::visit_delimiter_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_delimiter_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DelimiterValue::Comma => {}
             DelimiterValue::Solidus => {}
@@ -30452,121 +9023,45 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DelimiterValue {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Dimension {
-    #[doc = "Calls [VisitAstPath`::visit_dimension`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dimension(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Dimension {
+    #[doc = "Calls [Visit`::visit_dimension`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_dimension(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Dimension::Length { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
-                    self,
-                    self::fields::DimensionField::Length,
-                ));
-                <Length as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Length as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Dimension::Angle { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
-                    self,
-                    self::fields::DimensionField::Angle,
-                ));
-                <Angle as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Angle as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Dimension::Time { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
-                    self,
-                    self::fields::DimensionField::Time,
-                ));
-                <Time as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Time as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Dimension::Frequency { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
-                    self,
-                    self::fields::DimensionField::Frequency,
-                ));
-                <Frequency as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Frequency as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Dimension::Resolution { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
-                    self,
-                    self::fields::DimensionField::Resolution,
-                ));
-                <Resolution as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Resolution as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Dimension::Flex { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
-                    self,
-                    self::fields::DimensionField::Flex,
-                ));
-                <Flex as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Flex as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Dimension::UnknownDimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
-                    self,
-                    self::fields::DimensionField::UnknownDimension,
-                ));
-                <UnknownDimension as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UnknownDimension as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DimensionToken {
-    #[doc = "Calls [VisitAstPath`::visit_dimension_token`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_dimension_token(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DimensionToken {
+    #[doc = "Calls [Visit`::visit_dimension_token`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_dimension_token(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DimensionToken {
                 value,
@@ -30576,974 +9071,397 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DimensionToken {
                 raw_unit,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
-                        self,
-                        self::fields::DimensionTokenField::RawValue,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw_value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw_value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
-                        self,
-                        self::fields::DimensionTokenField::Unit,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(unit, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
-                        self,
-                        self::fields::DimensionTokenField::TypeFlag,
-                    ));
-                    <NumberType as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_flag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <NumberType as VisitWith<V>>::visit_with(type_flag, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
-                        self,
-                        self::fields::DimensionTokenField::RawUnit,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw_unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw_unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DocumentPrelude {
-    #[doc = "Calls [VisitAstPath`::visit_document_prelude`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DocumentPrelude {
+    #[doc = "Calls [Visit`::visit_document_prelude`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_document_prelude(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DocumentPrelude {
                 span,
                 matching_functions,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DocumentPrelude(
-                        self,
-                        self::fields::DocumentPreludeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DocumentPrelude(
-                        self,
-                        self::fields::DocumentPreludeField::MatchingFunctions(usize::MAX),
-                    ));
-                    < Vec < DocumentPreludeMatchingFunction > as VisitWithAstPath < V > > :: visit_with_ast_path (matching_functions , visitor , & mut * __ast_path)
+                    <Vec<DocumentPreludeMatchingFunction> as VisitWith<V>>::visit_with(
+                        matching_functions,
+                        visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DocumentPreludeMatchingFunction {
-    #[doc = "Calls [VisitAstPath`::visit_document_prelude_matching_function`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude_matching_function(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DocumentPreludeMatchingFunction {
+    #[doc = "Calls [Visit`::visit_document_prelude_matching_function`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_document_prelude_matching_function(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DocumentPreludeMatchingFunction::Url { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::DocumentPreludeMatchingFunction(
-                        self,
-                        self::fields::DocumentPreludeMatchingFunctionField::Url,
-                    ));
-                <Url as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Url as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             DocumentPreludeMatchingFunction::Function { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::DocumentPreludeMatchingFunction(
-                        self,
-                        self::fields::DocumentPreludeMatchingFunctionField::Function,
-                    ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExtensionName {
-    #[doc = "Calls [VisitAstPath`::visit_extension_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_extension_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExtensionName {
+    #[doc = "Calls [Visit`::visit_extension_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_extension_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExtensionName { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExtensionName(
-                        self,
-                        self::fields::ExtensionNameField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExtensionName(
-                        self,
-                        self::fields::ExtensionNameField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExtensionName(
-                        self,
-                        self::fields::ExtensionNameField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FamilyName {
-    #[doc = "Calls [VisitAstPath`::visit_family_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_family_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for FamilyName {
+    #[doc = "Calls [Visit`::visit_family_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_family_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             FamilyName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FamilyName(
-                    self,
-                    self::fields::FamilyNameField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             FamilyName::SequenceOfCustomIdents { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FamilyName(
-                    self,
-                    self::fields::FamilyNameField::SequenceOfCustomIdents,
-                ));
-                <SequenceOfCustomIdents as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SequenceOfCustomIdents as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Flex {
-    #[doc = "Calls [VisitAstPath`::visit_flex`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_flex(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Flex {
+    #[doc = "Calls [Visit`::visit_flex`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_flex(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            Flex { span, value, unit } => {
-                {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Flex(self, self::fields::FlexField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Flex { span, value, unit } => {
+                {
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Flex(self, self::fields::FlexField::Value));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Flex(self, self::fields::FlexField::Unit));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FontFeatureValuesPrelude {
-    #[doc = "Calls [VisitAstPath`::visit_font_feature_values_prelude`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_font_feature_values_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for FontFeatureValuesPrelude {
+    #[doc = "Calls [Visit`::visit_font_feature_values_prelude`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_font_feature_values_prelude(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             FontFeatureValuesPrelude { span, font_family } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::FontFeatureValuesPrelude(
-                            self,
-                            self::fields::FontFeatureValuesPreludeField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::FontFeatureValuesPrelude(
-                            self,
-                            self::fields::FontFeatureValuesPreludeField::FontFamily(usize::MAX),
-                        ));
-                    <Vec<FamilyName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        font_family,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<FamilyName> as VisitWith<V>>::visit_with(font_family, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingComplexSelector {
-    #[doc = "Calls [VisitAstPath`::visit_forgiving_complex_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_complex_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForgivingComplexSelector {
+    #[doc = "Calls [Visit`::visit_forgiving_complex_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_forgiving_complex_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ForgivingComplexSelector::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::ForgivingComplexSelector(
-                        self,
-                        self::fields::ForgivingComplexSelectorField::ComplexSelector,
-                    ));
-                <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComplexSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::ForgivingComplexSelector(
-                        self,
-                        self::fields::ForgivingComplexSelectorField::ListOfComponentValues,
-                    ));
-                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingRelativeSelector {
-    #[doc = "Calls [VisitAstPath`::visit_forgiving_relative_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForgivingRelativeSelector {
+    #[doc = "Calls [Visit`::visit_forgiving_relative_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_forgiving_relative_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ForgivingRelativeSelector::RelativeSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelector(
-                        self,
-                        self::fields::ForgivingRelativeSelectorField::RelativeSelector,
-                    ));
-                <RelativeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RelativeSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelector(
-                        self,
-                        self::fields::ForgivingRelativeSelectorField::ListOfComponentValues,
-                    ));
-                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingRelativeSelectorList {
-    #[doc = "Calls [VisitAstPath`::visit_forgiving_relative_selector_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForgivingRelativeSelectorList {
+    #[doc = "Calls [Visit`::visit_forgiving_relative_selector_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_forgiving_relative_selector_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ForgivingRelativeSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelectorList(
-                            self,
-                            self::fields::ForgivingRelativeSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelectorList(
-                            self,
-                            self::fields::ForgivingRelativeSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<ForgivingRelativeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ForgivingRelativeSelector> as VisitWith<V>>::visit_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingSelectorList {
-    #[doc = "Calls [VisitAstPath`::visit_forgiving_selector_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForgivingSelectorList {
+    #[doc = "Calls [Visit`::visit_forgiving_selector_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_forgiving_selector_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ForgivingSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ForgivingSelectorList(
-                            self,
-                            self::fields::ForgivingSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ForgivingSelectorList(
-                            self,
-                            self::fields::ForgivingSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<ForgivingComplexSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ForgivingComplexSelector> as VisitWith<V>>::visit_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Frequency {
-    #[doc = "Calls [VisitAstPath`::visit_frequency`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_frequency(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Frequency {
+    #[doc = "Calls [Visit`::visit_frequency`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_frequency(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Frequency { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Frequency(
-                        self,
-                        self::fields::FrequencyField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Frequency(
-                        self,
-                        self::fields::FrequencyField::Value,
-                    ));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Frequency(
-                        self,
-                        self::fields::FrequencyField::Unit,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FrequencyPercentage {
-    #[doc = "Calls [VisitAstPath`::visit_frequency_percentage`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_frequency_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for FrequencyPercentage {
+    #[doc = "Calls [Visit`::visit_frequency_percentage`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_frequency_percentage(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             FrequencyPercentage::Frequency { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FrequencyPercentage(
-                    self,
-                    self::fields::FrequencyPercentageField::Frequency,
-                ));
-                <Frequency as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Frequency as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             FrequencyPercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FrequencyPercentage(
-                    self,
-                    self::fields::FrequencyPercentageField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Function {
-    #[doc = "Calls [VisitAstPath`::visit_function`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Function {
+    #[doc = "Calls [Visit`::visit_function`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_function(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Function { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Name,
-                    ));
-                    <FunctionName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <FunctionName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FunctionName {
-    #[doc = "Calls [VisitAstPath`::visit_function_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for FunctionName {
+    #[doc = "Calls [Visit`::visit_function_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_function_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             FunctionName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FunctionName(
-                    self,
-                    self::fields::FunctionNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             FunctionName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FunctionName(
-                    self,
-                    self::fields::FunctionNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for GeneralEnclosed {
-    #[doc = "Calls [VisitAstPath`::visit_general_enclosed`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_general_enclosed(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for GeneralEnclosed {
+    #[doc = "Calls [Visit`::visit_general_enclosed`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_general_enclosed(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             GeneralEnclosed::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GeneralEnclosed(
-                    self,
-                    self::fields::GeneralEnclosedField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             GeneralEnclosed::SimpleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GeneralEnclosed(
-                    self,
-                    self::fields::GeneralEnclosedField::SimpleBlock,
-                ));
-                <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SimpleBlock as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for HexColor {
-    #[doc = "Calls [VisitAstPath`::visit_hex_color`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_hex_color(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for HexColor {
+    #[doc = "Calls [Visit`::visit_hex_color`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_hex_color(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             HexColor { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::HexColor(
-                        self,
-                        self::fields::HexColorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::HexColor(
-                        self,
-                        self::fields::HexColorField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::HexColor(
-                        self,
-                        self::fields::HexColorField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Hue {
-    #[doc = "Calls [VisitAstPath`::visit_hue`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_hue(visitor, self, __ast_path)
+}
+impl<V: ?Sized + Visit> VisitWith<V> for Hue {
+    #[doc = "Calls [Visit`::visit_hue`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_hue(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Hue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Hue(self, self::fields::HueField::Number));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Hue::Angle { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Hue(self, self::fields::HueField::Angle));
-                <Angle as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Angle as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for IdSelector {
-    #[doc = "Calls [VisitAstPath`::visit_id_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_id_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for IdSelector {
+    #[doc = "Calls [Visit`::visit_id_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_id_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             IdSelector { span, text } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdSelector(
-                        self,
-                        self::fields::IdSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdSelector(
-                        self,
-                        self::fields::IdSelectorField::Text,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        text,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(text, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Ident {
-    #[doc = "Calls [VisitAstPath`::visit_ident`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Ident {
+    #[doc = "Calls [Visit`::visit_ident`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ident(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Ident { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
-                        self,
-                        self::fields::IdentField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
-                        self,
-                        self::fields::IdentField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Ident(self, self::fields::IdentField::Raw));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportConditions {
-    #[doc = "Calls [VisitAstPath`::visit_import_conditions`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_conditions(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportConditions {
+    #[doc = "Calls [Visit`::visit_import_conditions`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_conditions(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportConditions {
                 span,
@@ -31551,145 +9469,59 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportConditions {
                 media,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportConditions(
-                        self,
-                        self::fields::ImportConditionsField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportConditions(
-                        self,
-                        self::fields::ImportConditionsField::Supports,
-                    ));
-                    <Option<Box<Function>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        supports,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Function>> as VisitWith<V>>::visit_with(supports, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportConditions(
-                        self,
-                        self::fields::ImportConditionsField::Media,
-                    ));
-                    <Option<Box<MediaQueryList>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        media,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<MediaQueryList>> as VisitWith<V>>::visit_with(media, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportHref {
-    #[doc = "Calls [VisitAstPath`::visit_import_href`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_href(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportHref {
+    #[doc = "Calls [Visit`::visit_import_href`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_href(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportHref::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportHref(
-                    self,
-                    self::fields::ImportHrefField::Url,
-                ));
-                <Url as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Url as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ImportHref::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportHref(
-                    self,
-                    self::fields::ImportHrefField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportLayerName {
-    #[doc = "Calls [VisitAstPath`::visit_import_layer_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_layer_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportLayerName {
+    #[doc = "Calls [Visit`::visit_import_layer_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_layer_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportLayerName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportLayerName(
-                    self,
-                    self::fields::ImportLayerNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ImportLayerName::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportLayerName(
-                    self,
-                    self::fields::ImportLayerNameField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportPrelude {
-    #[doc = "Calls [VisitAstPath`::visit_import_prelude`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportPrelude {
+    #[doc = "Calls [Visit`::visit_import_prelude`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_prelude(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportPrelude {
                 span,
@@ -31698,160 +9530,69 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportPrelude {
                 import_conditions,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
-                        self,
-                        self::fields::ImportPreludeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
-                        self,
-                        self::fields::ImportPreludeField::Href,
-                    ));
-                    <Box<ImportHref> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        href,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<ImportHref> as VisitWith<V>>::visit_with(href, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
-                        self,
-                        self::fields::ImportPreludeField::LayerName,
-                    ));
-                    <Option<Box<ImportLayerName>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        layer_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ImportLayerName>> as VisitWith<V>>::visit_with(layer_name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
-                        self,
-                        self::fields::ImportPreludeField::ImportConditions,
-                    ));
-                    <Option<Box<ImportConditions>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    <Option<Box<ImportConditions>> as VisitWith<V>>::visit_with(
                         import_conditions,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportantFlag {
-    #[doc = "Calls [VisitAstPath`::visit_important_flag`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_important_flag(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportantFlag {
+    #[doc = "Calls [Visit`::visit_important_flag`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_important_flag(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportantFlag { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportantFlag(
-                        self,
-                        self::fields::ImportantFlagField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportantFlag(
-                        self,
-                        self::fields::ImportantFlagField::Value,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Integer {
-    #[doc = "Calls [VisitAstPath`::visit_integer`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_integer(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Integer {
+    #[doc = "Calls [Visit`::visit_integer`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_integer(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Integer { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Integer(
-                        self,
-                        self::fields::IntegerField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Integer(
-                        self,
-                        self::fields::IntegerField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframeBlock {
-    #[doc = "Calls [VisitAstPath`::visit_keyframe_block`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_block(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for KeyframeBlock {
+    #[doc = "Calls [Visit`::visit_keyframe_block`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_keyframe_block(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             KeyframeBlock {
                 span,
@@ -31859,564 +9600,222 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframeBlock {
                 block,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeBlock(
-                        self,
-                        self::fields::KeyframeBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeBlock(
-                        self,
-                        self::fields::KeyframeBlockField::Prelude(usize::MAX),
-                    ));
-                    <Vec<KeyframeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<KeyframeSelector> as VisitWith<V>>::visit_with(prelude, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeBlock(
-                        self,
-                        self::fields::KeyframeBlockField::Block,
-                    ));
-                    <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SimpleBlock as VisitWith<V>>::visit_with(block, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframeSelector {
-    #[doc = "Calls [VisitAstPath`::visit_keyframe_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for KeyframeSelector {
+    #[doc = "Calls [Visit`::visit_keyframe_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_keyframe_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             KeyframeSelector::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeSelector(
-                    self,
-                    self::fields::KeyframeSelectorField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             KeyframeSelector::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeSelector(
-                    self,
-                    self::fields::KeyframeSelectorField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframesName {
-    #[doc = "Calls [VisitAstPath`::visit_keyframes_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for KeyframesName {
+    #[doc = "Calls [Visit`::visit_keyframes_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_keyframes_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             KeyframesName::CustomIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
-                    self,
-                    self::fields::KeyframesNameField::CustomIdent,
-                ));
-                <Box<CustomIdent> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<CustomIdent> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             KeyframesName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
-                    self,
-                    self::fields::KeyframesNameField::Str,
-                ));
-                <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Str> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             KeyframesName::PseudoPrefix { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
-                    self,
-                    self::fields::KeyframesNameField::PseudoPrefix,
-                ));
-                <Box<KeyframesPseudoPrefix> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<KeyframesPseudoPrefix> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             KeyframesName::PseudoFunction { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
-                    self,
-                    self::fields::KeyframesNameField::PseudoFunction,
-                ));
-                <Box<KeyframesPseudoFunction> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<KeyframesPseudoFunction> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframesPseudoFunction {
-    #[doc = "Calls [VisitAstPath`::visit_keyframes_pseudo_function`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_pseudo_function(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for KeyframesPseudoFunction {
+    #[doc = "Calls [Visit`::visit_keyframes_pseudo_function`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_keyframes_pseudo_function(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             KeyframesPseudoFunction { span, pseudo, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoFunction(
-                            self,
-                            self::fields::KeyframesPseudoFunctionField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoFunction(
-                            self,
-                            self::fields::KeyframesPseudoFunctionField::Pseudo,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        pseudo,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(pseudo, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoFunction(
-                            self,
-                            self::fields::KeyframesPseudoFunctionField::Name,
-                        ));
-                    <KeyframesName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <KeyframesName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframesPseudoPrefix {
-    #[doc = "Calls [VisitAstPath`::visit_keyframes_pseudo_prefix`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframes_pseudo_prefix(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for KeyframesPseudoPrefix {
+    #[doc = "Calls [Visit`::visit_keyframes_pseudo_prefix`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_keyframes_pseudo_prefix(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             KeyframesPseudoPrefix { span, pseudo, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoPrefix(
-                            self,
-                            self::fields::KeyframesPseudoPrefixField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoPrefix(
-                            self,
-                            self::fields::KeyframesPseudoPrefixField::Pseudo,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        pseudo,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(pseudo, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoPrefix(
-                            self,
-                            self::fields::KeyframesPseudoPrefixField::Name,
-                        ));
-                    <KeyframesName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <KeyframesName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LayerName {
-    #[doc = "Calls [VisitAstPath`::visit_layer_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for LayerName {
+    #[doc = "Calls [Visit`::visit_layer_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_layer_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             LayerName { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerName(
-                        self,
-                        self::fields::LayerNameField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerName(
-                        self,
-                        self::fields::LayerNameField::Name(usize::MAX),
-                    ));
-                    <Vec<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Ident> as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LayerNameList {
-    #[doc = "Calls [VisitAstPath`::visit_layer_name_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_name_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for LayerNameList {
+    #[doc = "Calls [Visit`::visit_layer_name_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_layer_name_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             LayerNameList { span, name_list } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerNameList(
-                        self,
-                        self::fields::LayerNameListField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerNameList(
-                        self,
-                        self::fields::LayerNameListField::NameList(usize::MAX),
-                    ));
-                    <Vec<LayerName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name_list,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<LayerName> as VisitWith<V>>::visit_with(name_list, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LayerPrelude {
-    #[doc = "Calls [VisitAstPath`::visit_layer_prelude`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for LayerPrelude {
+    #[doc = "Calls [Visit`::visit_layer_prelude`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_layer_prelude(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             LayerPrelude::Name { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerPrelude(
-                    self,
-                    self::fields::LayerPreludeField::Name,
-                ));
-                <LayerName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <LayerName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             LayerPrelude::NameList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerPrelude(
-                    self,
-                    self::fields::LayerPreludeField::NameList,
-                ));
-                <LayerNameList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <LayerNameList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Length {
-    #[doc = "Calls [VisitAstPath`::visit_length`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_length(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Length {
+    #[doc = "Calls [Visit`::visit_length`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_length(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Length { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Length(
-                        self,
-                        self::fields::LengthField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Length(
-                        self,
-                        self::fields::LengthField::Value,
-                    ));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Length(
-                        self,
-                        self::fields::LengthField::Unit,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LengthPercentage {
-    #[doc = "Calls [VisitAstPath`::visit_length_percentage`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_length_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for LengthPercentage {
+    #[doc = "Calls [Visit`::visit_length_percentage`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_length_percentage(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             LengthPercentage::Length { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LengthPercentage(
-                    self,
-                    self::fields::LengthPercentageField::Length,
-                ));
-                <Length as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Length as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             LengthPercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LengthPercentage(
-                    self,
-                    self::fields::LengthPercentageField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ListOfComponentValues {
-    #[doc = "Calls [VisitAstPath`::visit_list_of_component_values`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_list_of_component_values(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ListOfComponentValues {
+    #[doc = "Calls [Visit`::visit_list_of_component_values`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_list_of_component_values(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ListOfComponentValues { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ListOfComponentValues(
-                            self,
-                            self::fields::ListOfComponentValuesField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ListOfComponentValues(
-                            self,
-                            self::fields::ListOfComponentValuesField::Children(usize::MAX),
-                        ));
-                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaAnd {
-    #[doc = "Calls [VisitAstPath`::visit_media_and`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_and(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaAnd {
+    #[doc = "Calls [Visit`::visit_media_and`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_and(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaAnd {
                 span,
@@ -32424,534 +9823,206 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaAnd {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaAnd(
-                        self,
-                        self::fields::MediaAndField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaAnd(
-                        self,
-                        self::fields::MediaAndField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaAnd(
-                        self,
-                        self::fields::MediaAndField::Condition,
-                    ));
-                    <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaInParens as VisitWith<V>>::visit_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaCondition {
-    #[doc = "Calls [VisitAstPath`::visit_media_condition`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaCondition {
+    #[doc = "Calls [Visit`::visit_media_condition`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_condition(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaCondition { span, conditions } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaCondition(
-                        self,
-                        self::fields::MediaConditionField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaCondition(
-                        self,
-                        self::fields::MediaConditionField::Conditions(usize::MAX),
-                    ));
-                    <Vec<MediaConditionAllType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<MediaConditionAllType> as VisitWith<V>>::visit_with(conditions, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionAllType {
-    #[doc = "Calls [VisitAstPath`::visit_media_condition_all_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_all_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionAllType {
+    #[doc = "Calls [Visit`::visit_media_condition_all_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_condition_all_type(visitor, self)
     }
-
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            MediaConditionAllType::Not { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
-                        self,
-                        self::fields::MediaConditionAllTypeField::Not,
-                    ));
-                <MediaNot as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            MediaConditionAllType::And { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
-                        self,
-                        self::fields::MediaConditionAllTypeField::And,
-                    ));
-                <MediaAnd as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            MediaConditionAllType::Not { 0: _field_0 } => {
+                <MediaNot as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            MediaConditionAllType::And { 0: _field_0 } => {
+                <MediaAnd as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaConditionAllType::Or { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
-                        self,
-                        self::fields::MediaConditionAllTypeField::Or,
-                    ));
-                <MediaOr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaOr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaConditionAllType::MediaInParens { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
-                        self,
-                        self::fields::MediaConditionAllTypeField::MediaInParens,
-                    ));
-                <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaInParens as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionType {
-    #[doc = "Calls [VisitAstPath`::visit_media_condition_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionType {
+    #[doc = "Calls [Visit`::visit_media_condition_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_condition_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaConditionType::All { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaConditionType(
-                    self,
-                    self::fields::MediaConditionTypeField::All,
-                ));
-                <MediaCondition as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaCondition as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaConditionType::WithoutOr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaConditionType(
-                    self,
-                    self::fields::MediaConditionTypeField::WithoutOr,
-                ));
-                <MediaConditionWithoutOr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaConditionWithoutOr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionWithoutOr {
-    #[doc = "Calls [VisitAstPath`::visit_media_condition_without_or`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionWithoutOr {
+    #[doc = "Calls [Visit`::visit_media_condition_without_or`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_condition_without_or(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaConditionWithoutOr { span, conditions } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOr(
-                            self,
-                            self::fields::MediaConditionWithoutOrField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOr(
-                            self,
-                            self::fields::MediaConditionWithoutOrField::Conditions(usize::MAX),
-                        ));
-                    <Vec<MediaConditionWithoutOrType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
+                    <Vec<MediaConditionWithoutOrType> as VisitWith<V>>::visit_with(
+                        conditions, visitor,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionWithoutOrType {
-    #[doc = "Calls [VisitAstPath`::visit_media_condition_without_or_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaConditionWithoutOrType {
+    #[doc = "Calls [Visit`::visit_media_condition_without_or_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_condition_without_or_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaConditionWithoutOrType::Not { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOrType(
-                        self,
-                        self::fields::MediaConditionWithoutOrTypeField::Not,
-                    ));
-                <MediaNot as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaNot as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaConditionWithoutOrType::And { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOrType(
-                        self,
-                        self::fields::MediaConditionWithoutOrTypeField::And,
-                    ));
-                <MediaAnd as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaAnd as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaConditionWithoutOrType::MediaInParens { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOrType(
-                        self,
-                        self::fields::MediaConditionWithoutOrTypeField::MediaInParens,
-                    ));
-                <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaInParens as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeature {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeature {
+    #[doc = "Calls [Visit`::visit_media_feature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeature::Plain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
-                    self,
-                    self::fields::MediaFeatureField::Plain,
-                ));
-                <MediaFeaturePlain as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeaturePlain as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeature::Boolean { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
-                    self,
-                    self::fields::MediaFeatureField::Boolean,
-                ));
-                <MediaFeatureBoolean as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeatureBoolean as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeature::Range { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
-                    self,
-                    self::fields::MediaFeatureField::Range,
-                ));
-                <MediaFeatureRange as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeatureRange as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeature::RangeInterval { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
-                    self,
-                    self::fields::MediaFeatureField::RangeInterval,
-                ));
-                <MediaFeatureRangeInterval as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeatureRangeInterval as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureBoolean {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature_boolean`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_boolean(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureBoolean {
+    #[doc = "Calls [Visit`::visit_media_feature_boolean`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature_boolean(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeatureBoolean { span, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureBoolean(
-                            self,
-                            self::fields::MediaFeatureBooleanField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureBoolean(
-                            self,
-                            self::fields::MediaFeatureBooleanField::Name,
-                        ));
-                    <MediaFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureName {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureName {
+    #[doc = "Calls [Visit`::visit_media_feature_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeatureName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureName(
-                    self,
-                    self::fields::MediaFeatureNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeatureName::ExtensionName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureName(
-                    self,
-                    self::fields::MediaFeatureNameField::ExtensionName,
-                ));
-                <ExtensionName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExtensionName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeaturePlain {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature_plain`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_plain(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeaturePlain {
+    #[doc = "Calls [Visit`::visit_media_feature_plain`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature_plain(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeaturePlain { span, name, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeaturePlain(
-                            self,
-                            self::fields::MediaFeaturePlainField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeaturePlain(
-                            self,
-                            self::fields::MediaFeaturePlainField::Name,
-                        ));
-                    <MediaFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeaturePlain(
-                            self,
-                            self::fields::MediaFeaturePlainField::Value,
-                        ));
-                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRange {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature_range`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureRange {
+    #[doc = "Calls [Visit`::visit_media_feature_range`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature_range(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeatureRange {
                 span,
@@ -32960,74 +10031,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRange {
                 right,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
-                            self,
-                            self::fields::MediaFeatureRangeField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
-                            self,
-                            self::fields::MediaFeatureRangeField::Left,
-                        ));
-                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
-                            self,
-                            self::fields::MediaFeatureRangeField::Comparison,
-                        ));
-                    <MediaFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
-                        comparison,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureRangeComparison as VisitWith<V>>::visit_with(comparison, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
-                            self,
-                            self::fields::MediaFeatureRangeField::Right,
-                        ));
-                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRangeComparison {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature_range_comparison`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range_comparison(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureRangeComparison {
+    #[doc = "Calls [Visit`::visit_media_feature_range_comparison`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature_range_comparison(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeatureRangeComparison::Lt => {}
             MediaFeatureRangeComparison::Le => {}
@@ -33037,23 +10062,13 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRangeComparis
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRangeInterval {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature_range_interval`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_range_interval(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureRangeInterval {
+    #[doc = "Calls [Visit`::visit_media_feature_range_interval`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature_range_interval(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeatureRangeInterval {
                 span,
@@ -33064,228 +10079,86 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRangeInterval
                 right,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
-                            self,
-                            self::fields::MediaFeatureRangeIntervalField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
-                            self,
-                            self::fields::MediaFeatureRangeIntervalField::Left,
-                        ));
-                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
-                            self,
-                            self::fields::MediaFeatureRangeIntervalField::LeftComparison,
-                        ));
-                    <MediaFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
+                    <MediaFeatureRangeComparison as VisitWith<V>>::visit_with(
                         left_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
-                            self,
-                            self::fields::MediaFeatureRangeIntervalField::Name,
-                        ));
-                    <MediaFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
-                            self,
-                            self::fields::MediaFeatureRangeIntervalField::RightComparison,
-                        ));
-                    <MediaFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
+                    <MediaFeatureRangeComparison as VisitWith<V>>::visit_with(
                         right_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
-                            self,
-                            self::fields::MediaFeatureRangeIntervalField::Right,
-                        ));
-                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureValue {
-    #[doc = "Calls [VisitAstPath`::visit_media_feature_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_feature_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaFeatureValue {
+    #[doc = "Calls [Visit`::visit_media_feature_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_feature_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaFeatureValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
-                    self,
-                    self::fields::MediaFeatureValueField::Number,
-                ));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeatureValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
-                    self,
-                    self::fields::MediaFeatureValueField::Dimension,
-                ));
-                <Dimension as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Dimension as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeatureValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
-                    self,
-                    self::fields::MediaFeatureValueField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeatureValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
-                    self,
-                    self::fields::MediaFeatureValueField::Ratio,
-                ));
-                <Ratio as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ratio as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaFeatureValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
-                    self,
-                    self::fields::MediaFeatureValueField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaInParens {
-    #[doc = "Calls [VisitAstPath`::visit_media_in_parens`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaInParens {
+    #[doc = "Calls [Visit`::visit_media_in_parens`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_in_parens(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaInParens::MediaCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaInParens(
-                    self,
-                    self::fields::MediaInParensField::MediaCondition,
-                ));
-                <MediaCondition as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaCondition as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaInParens::Feature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaInParens(
-                    self,
-                    self::fields::MediaInParensField::Feature,
-                ));
-                <Box<MediaFeature> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<MediaFeature> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MediaInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaInParens(
-                    self,
-                    self::fields::MediaInParensField::GeneralEnclosed,
-                ));
-                <GeneralEnclosed as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GeneralEnclosed as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaNot {
-    #[doc = "Calls [VisitAstPath`::visit_media_not`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_not(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaNot {
+    #[doc = "Calls [Visit`::visit_media_not`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_not(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaNot {
                 span,
@@ -33293,59 +10166,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaNot {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaNot(
-                        self,
-                        self::fields::MediaNotField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaNot(
-                        self,
-                        self::fields::MediaNotField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaNot(
-                        self,
-                        self::fields::MediaNotField::Condition,
-                    ));
-                    <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaInParens as VisitWith<V>>::visit_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaOr {
-    #[doc = "Calls [VisitAstPath`::visit_media_or`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_or(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaOr {
+    #[doc = "Calls [Visit`::visit_media_or`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_or(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaOr {
                 span,
@@ -33353,59 +10192,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaOr {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaOr(
-                        self,
-                        self::fields::MediaOrField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaOr(
-                        self,
-                        self::fields::MediaOrField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaOr(
-                        self,
-                        self::fields::MediaOrField::Condition,
-                    ));
-                    <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaInParens as VisitWith<V>>::visit_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaQuery {
-    #[doc = "Calls [VisitAstPath`::visit_media_query`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_query(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaQuery {
+    #[doc = "Calls [Visit`::visit_media_query`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_query(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaQuery {
                 span,
@@ -33415,492 +10220,208 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaQuery {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
-                        self,
-                        self::fields::MediaQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
-                        self,
-                        self::fields::MediaQueryField::Modifier,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        modifier,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(modifier, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
-                        self,
-                        self::fields::MediaQueryField::MediaType,
-                    ));
-                    <Option<MediaType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        media_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<MediaType> as VisitWith<V>>::visit_with(media_type, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
-                        self,
-                        self::fields::MediaQueryField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
-                        self,
-                        self::fields::MediaQueryField::Condition,
-                    ));
-                    <Option<Box<MediaConditionType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
+                    <Option<Box<MediaConditionType>> as VisitWith<V>>::visit_with(
+                        condition, visitor,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaQueryList {
-    #[doc = "Calls [VisitAstPath`::visit_media_query_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_query_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaQueryList {
+    #[doc = "Calls [Visit`::visit_media_query_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_query_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaQueryList { span, queries } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQueryList(
-                        self,
-                        self::fields::MediaQueryListField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQueryList(
-                        self,
-                        self::fields::MediaQueryListField::Queries(usize::MAX),
-                    ));
-                    <Vec<MediaQuery> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        queries,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<MediaQuery> as VisitWith<V>>::visit_with(queries, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaType {
-    #[doc = "Calls [VisitAstPath`::visit_media_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MediaType {
+    #[doc = "Calls [Visit`::visit_media_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MediaType::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaType(
-                    self,
-                    self::fields::MediaTypeField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamedNamespace {
-    #[doc = "Calls [VisitAstPath`::visit_named_namespace`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_named_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NamedNamespace {
+    #[doc = "Calls [Visit`::visit_named_namespace`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_named_namespace(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NamedNamespace { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedNamespace(
-                        self,
-                        self::fields::NamedNamespaceField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedNamespace(
-                        self,
-                        self::fields::NamedNamespaceField::Name,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Namespace {
-    #[doc = "Calls [VisitAstPath`::visit_namespace`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Namespace {
+    #[doc = "Calls [Visit`::visit_namespace`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_namespace(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Namespace::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Namespace(
-                    self,
-                    self::fields::NamespaceField::Named,
-                ));
-                <NamedNamespace as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NamedNamespace as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Namespace::Any { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Namespace(
-                    self,
-                    self::fields::NamespaceField::Any,
-                ));
-                <AnyNamespace as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AnyNamespace as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamespacePrefix {
-    #[doc = "Calls [VisitAstPath`::visit_namespace_prefix`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prefix(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NamespacePrefix {
+    #[doc = "Calls [Visit`::visit_namespace_prefix`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_namespace_prefix(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NamespacePrefix { span, namespace } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrefix(
-                        self,
-                        self::fields::NamespacePrefixField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrefix(
-                        self,
-                        self::fields::NamespacePrefixField::Namespace,
-                    ));
-                    <Option<Namespace> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        namespace,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Namespace> as VisitWith<V>>::visit_with(namespace, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamespacePrelude {
-    #[doc = "Calls [VisitAstPath`::visit_namespace_prelude`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NamespacePrelude {
+    #[doc = "Calls [Visit`::visit_namespace_prelude`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_namespace_prelude(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NamespacePrelude { span, prefix, uri } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrelude(
-                        self,
-                        self::fields::NamespacePreludeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrelude(
-                        self,
-                        self::fields::NamespacePreludeField::Prefix,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(prefix, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrelude(
-                        self,
-                        self::fields::NamespacePreludeField::Uri,
-                    ));
-                    <Box<NamespacePreludeUri> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        uri,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<NamespacePreludeUri> as VisitWith<V>>::visit_with(uri, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamespacePreludeUri {
-    #[doc = "Calls [VisitAstPath`::visit_namespace_prelude_uri`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_namespace_prelude_uri(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NamespacePreludeUri {
+    #[doc = "Calls [Visit`::visit_namespace_prelude_uri`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_namespace_prelude_uri(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NamespacePreludeUri::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePreludeUri(
-                    self,
-                    self::fields::NamespacePreludeUriField::Url,
-                ));
-                <Url as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Url as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             NamespacePreludeUri::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePreludeUri(
-                    self,
-                    self::fields::NamespacePreludeUriField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NestingSelector {
-    #[doc = "Calls [VisitAstPath`::visit_nesting_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_nesting_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NestingSelector {
+    #[doc = "Calls [Visit`::visit_nesting_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_nesting_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NestingSelector { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NestingSelector(
-                        self,
-                        self::fields::NestingSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Number {
-    #[doc = "Calls [VisitAstPath`::visit_number`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_number(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Number {
+    #[doc = "Calls [Visit`::visit_number`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_number(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Number { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
-                        self,
-                        self::fields::NumberField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
-                        self,
-                        self::fields::NumberField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NumberType {
-    #[doc = "Calls [VisitAstPath`::visit_number_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_number_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NumberType {
+    #[doc = "Calls [Visit`::visit_number_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_number_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NumberType::Integer => {}
             NumberType::Number => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelector {
-    #[doc = "Calls [VisitAstPath`::visit_page_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PageSelector {
+    #[doc = "Calls [Visit`::visit_page_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_page_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PageSelector {
                 span,
@@ -33908,241 +10429,101 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelector {
                 pseudos,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelector(
-                        self,
-                        self::fields::PageSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelector(
-                        self,
-                        self::fields::PageSelectorField::PageType,
-                    ));
-                    <Option<PageSelectorType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        page_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<PageSelectorType> as VisitWith<V>>::visit_with(page_type, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelector(
-                        self,
-                        self::fields::PageSelectorField::Pseudos(usize::MAX),
-                    ));
-                    <Option<Vec<PageSelectorPseudo>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        pseudos,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Vec<PageSelectorPseudo>> as VisitWith<V>>::visit_with(pseudos, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelectorList {
-    #[doc = "Calls [VisitAstPath`::visit_page_selector_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PageSelectorList {
+    #[doc = "Calls [Visit`::visit_page_selector_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_page_selector_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PageSelectorList { span, selectors } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorList(
-                        self,
-                        self::fields::PageSelectorListField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorList(
-                        self,
-                        self::fields::PageSelectorListField::Selectors(usize::MAX),
-                    ));
-                    <Vec<PageSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        selectors,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<PageSelector> as VisitWith<V>>::visit_with(selectors, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelectorPseudo {
-    #[doc = "Calls [VisitAstPath`::visit_page_selector_pseudo`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_pseudo(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PageSelectorPseudo {
+    #[doc = "Calls [Visit`::visit_page_selector_pseudo`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_page_selector_pseudo(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PageSelectorPseudo { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PageSelectorPseudo(
-                            self,
-                            self::fields::PageSelectorPseudoField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PageSelectorPseudo(
-                            self,
-                            self::fields::PageSelectorPseudoField::Value,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelectorType {
-    #[doc = "Calls [VisitAstPath`::visit_page_selector_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_page_selector_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PageSelectorType {
+    #[doc = "Calls [Visit`::visit_page_selector_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_page_selector_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PageSelectorType { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorType(
-                        self,
-                        self::fields::PageSelectorTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorType(
-                        self,
-                        self::fields::PageSelectorTypeField::Value,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Percentage {
-    #[doc = "Calls [VisitAstPath`::visit_percentage`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Percentage {
+    #[doc = "Calls [Visit`::visit_percentage`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_percentage(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Percentage { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Percentage(
-                        self,
-                        self::fields::PercentageField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Percentage(
-                        self,
-                        self::fields::PercentageField::Value,
-                    ));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoClassSelector {
-    #[doc = "Calls [VisitAstPath`::visit_pseudo_class_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PseudoClassSelector {
+    #[doc = "Calls [Visit`::visit_pseudo_class_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pseudo_class_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PseudoClassSelector {
                 span,
@@ -34150,223 +10531,74 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoClassSelector {
                 children,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PseudoClassSelector(
-                            self,
-                            self::fields::PseudoClassSelectorField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PseudoClassSelector(
-                            self,
-                            self::fields::PseudoClassSelectorField::Name,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PseudoClassSelector(
-                            self,
-                            self::fields::PseudoClassSelectorField::Children(usize::MAX),
-                        ));
-                    < Option < Vec < PseudoClassSelectorChildren > > as VisitWithAstPath < V > > :: visit_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Option<Vec<PseudoClassSelectorChildren>> as VisitWith<V>>::visit_with(
+                        children, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoClassSelectorChildren {
-    #[doc = "Calls [VisitAstPath`::visit_pseudo_class_selector_children`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PseudoClassSelectorChildren {
+    #[doc = "Calls [Visit`::visit_pseudo_class_selector_children`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pseudo_class_selector_children(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PseudoClassSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::PreservedToken,
-                    ));
-                <TokenAndSpan as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TokenAndSpan as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::AnPlusB { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::AnPlusB,
-                    ));
-                <AnPlusB as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AnPlusB as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::Ident,
-                    ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            PseudoClassSelectorChildren::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::Str,
-                    ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::Delimiter,
-                    ));
-                <Delimiter as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::ComplexSelector,
-                    ));
-                <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            PseudoClassSelectorChildren::Str { 0: _field_0 } => {
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
+                <Delimiter as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
+                <ComplexSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::SelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::SelectorList,
-                    ));
-                <SelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::ForgivingSelectorList,
-                    ));
-                <ForgivingSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForgivingSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::CompoundSelectorList,
-                    ));
-                <CompoundSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::RelativeSelectorList,
-                    ));
-                <RelativeSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RelativeSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                    self,
-                    self::fields::PseudoClassSelectorChildrenField::ForgivingRelativeSelectorList,
-                ));
-                <ForgivingRelativeSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForgivingRelativeSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
-                        self,
-                        self::fields::PseudoClassSelectorChildrenField::CompoundSelector,
-                    ));
-                <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoElementSelector {
-    #[doc = "Calls [VisitAstPath`::visit_pseudo_element_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PseudoElementSelector {
+    #[doc = "Calls [Visit`::visit_pseudo_element_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pseudo_element_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PseudoElementSelector {
                 span,
@@ -34374,127 +10606,50 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoElementSelector {
                 children,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PseudoElementSelector(
-                            self,
-                            self::fields::PseudoElementSelectorField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PseudoElementSelector(
-                            self,
-                            self::fields::PseudoElementSelectorField::Name,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::PseudoElementSelector(
-                            self,
-                            self::fields::PseudoElementSelectorField::Children(usize::MAX),
-                        ));
-                    < Option < Vec < PseudoElementSelectorChildren > > as VisitWithAstPath < V > > :: visit_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Option<Vec<PseudoElementSelectorChildren>> as VisitWith<V>>::visit_with(
+                        children, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoElementSelectorChildren {
-    #[doc = "Calls [VisitAstPath`::visit_pseudo_element_selector_children`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PseudoElementSelectorChildren {
+    #[doc = "Calls [Visit`::visit_pseudo_element_selector_children`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pseudo_element_selector_children(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PseudoElementSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
-                        self,
-                        self::fields::PseudoElementSelectorChildrenField::PreservedToken,
-                    ));
-                <TokenAndSpan as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TokenAndSpan as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
-                        self,
-                        self::fields::PseudoElementSelectorChildrenField::Ident,
-                    ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
-                        self,
-                        self::fields::PseudoElementSelectorChildrenField::CompoundSelector,
-                    ));
-                <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
-                        self,
-                        self::fields::PseudoElementSelectorChildrenField::CustomHighlightName,
-                    ));
-                <CustomHighlightName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomHighlightName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for QualifiedRule {
-    #[doc = "Calls [VisitAstPath`::visit_qualified_rule`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_qualified_rule(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for QualifiedRule {
+    #[doc = "Calls [Visit`::visit_qualified_rule`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_qualified_rule(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             QualifiedRule {
                 span,
@@ -34502,223 +10657,87 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for QualifiedRule {
                 block,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRule(
-                        self,
-                        self::fields::QualifiedRuleField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRule(
-                        self,
-                        self::fields::QualifiedRuleField::Prelude,
-                    ));
-                    <QualifiedRulePrelude as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QualifiedRulePrelude as VisitWith<V>>::visit_with(prelude, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRule(
-                        self,
-                        self::fields::QualifiedRuleField::Block,
-                    ));
-                    <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SimpleBlock as VisitWith<V>>::visit_with(block, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for QualifiedRulePrelude {
-    #[doc = "Calls [VisitAstPath`::visit_qualified_rule_prelude`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_qualified_rule_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for QualifiedRulePrelude {
+    #[doc = "Calls [Visit`::visit_qualified_rule_prelude`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_qualified_rule_prelude(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             QualifiedRulePrelude::SelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRulePrelude(
-                    self,
-                    self::fields::QualifiedRulePreludeField::SelectorList,
-                ));
-                <SelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRulePrelude(
-                    self,
-                    self::fields::QualifiedRulePreludeField::RelativeSelectorList,
-                ));
-                <RelativeSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RelativeSelectorList as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRulePrelude(
-                    self,
-                    self::fields::QualifiedRulePreludeField::ListOfComponentValues,
-                ));
-                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for QueryInParens {
-    #[doc = "Calls [VisitAstPath`::visit_query_in_parens`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_query_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for QueryInParens {
+    #[doc = "Calls [Visit`::visit_query_in_parens`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_query_in_parens(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             QueryInParens::ContainerQuery { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QueryInParens(
-                    self,
-                    self::fields::QueryInParensField::ContainerQuery,
-                ));
-                <Box<ContainerQuery> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ContainerQuery> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             QueryInParens::SizeFeature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QueryInParens(
-                    self,
-                    self::fields::QueryInParensField::SizeFeature,
-                ));
-                <SizeFeature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             QueryInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QueryInParens(
-                    self,
-                    self::fields::QueryInParensField::GeneralEnclosed,
-                ));
-                <GeneralEnclosed as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GeneralEnclosed as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Ratio {
-    #[doc = "Calls [VisitAstPath`::visit_ratio`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ratio(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Ratio {
+    #[doc = "Calls [Visit`::visit_ratio`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ratio(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Ratio { span, left, right } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ratio(
-                        self,
-                        self::fields::RatioField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ratio(
-                        self,
-                        self::fields::RatioField::Left,
-                    ));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ratio(
-                        self,
-                        self::fields::RatioField::Right,
-                    ));
-                    <Option<Number> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Number> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RelativeSelector {
-    #[doc = "Calls [VisitAstPath`::visit_relative_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for RelativeSelector {
+    #[doc = "Calls [Visit`::visit_relative_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_relative_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             RelativeSelector {
                 span,
@@ -34726,216 +10745,86 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RelativeSelector {
                 selector,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RelativeSelector(
-                        self,
-                        self::fields::RelativeSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RelativeSelector(
-                        self,
-                        self::fields::RelativeSelectorField::Combinator,
-                    ));
-                    <Option<Combinator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        combinator,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Combinator> as VisitWith<V>>::visit_with(combinator, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RelativeSelector(
-                        self,
-                        self::fields::RelativeSelectorField::Selector,
-                    ));
-                    <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                        selector,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ComplexSelector as VisitWith<V>>::visit_with(selector, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RelativeSelectorList {
-    #[doc = "Calls [VisitAstPath`::visit_relative_selector_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_relative_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for RelativeSelectorList {
+    #[doc = "Calls [Visit`::visit_relative_selector_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_relative_selector_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             RelativeSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::RelativeSelectorList(
-                            self,
-                            self::fields::RelativeSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::RelativeSelectorList(
-                            self,
-                            self::fields::RelativeSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<RelativeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<RelativeSelector> as VisitWith<V>>::visit_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Resolution {
-    #[doc = "Calls [VisitAstPath`::visit_resolution`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_resolution(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Resolution {
+    #[doc = "Calls [Visit`::visit_resolution`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_resolution(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Resolution { span, value, unit } => {
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Resolution(
-                        self,
-                        self::fields::ResolutionField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                {
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Resolution(
-                        self,
-                        self::fields::ResolutionField::Value,
-                    ));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Resolution(
-                        self,
-                        self::fields::ResolutionField::Unit,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Rule {
-    #[doc = "Calls [VisitAstPath`::visit_rule`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_rule(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Rule {
+    #[doc = "Calls [Visit`::visit_rule`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_rule(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Rule::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Rule(
-                    self,
-                    self::fields::RuleField::QualifiedRule,
-                ));
-                <Box<QualifiedRule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<QualifiedRule> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Rule::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Rule(
-                    self,
-                    self::fields::RuleField::AtRule,
-                ));
-                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Rule::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Rule(
-                    self,
-                    self::fields::RuleField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ScopeRange {
-    #[doc = "Calls [VisitAstPath`::visit_scope_range`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_scope_range(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ScopeRange {
+    #[doc = "Calls [Visit`::visit_scope_range`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_scope_range(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ScopeRange {
                 span,
@@ -34943,407 +10832,166 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ScopeRange {
                 scope_end,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ScopeRange(
-                        self,
-                        self::fields::ScopeRangeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ScopeRange(
-                        self,
-                        self::fields::ScopeRangeField::ScopeStart,
-                    ));
-                    <Option<ForgivingSelectorList> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    <Option<ForgivingSelectorList> as VisitWith<V>>::visit_with(
                         scope_start,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ScopeRange(
-                        self,
-                        self::fields::ScopeRangeField::ScopeEnd,
-                    ));
-                    <Option<ForgivingSelectorList> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        scope_end,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ForgivingSelectorList> as VisitWith<V>>::visit_with(scope_end, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SelectorList {
-    #[doc = "Calls [VisitAstPath`::visit_selector_list`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SelectorList {
+    #[doc = "Calls [Visit`::visit_selector_list`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_selector_list(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SelectorList { span, children } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SelectorList(
-                        self,
-                        self::fields::SelectorListField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SelectorList(
-                        self,
-                        self::fields::SelectorListField::Children(usize::MAX),
-                    ));
-                    <Vec<ComplexSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComplexSelector> as VisitWith<V>>::visit_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SequenceOfCustomIdents {
-    #[doc = "Calls [VisitAstPath`::visit_sequence_of_custom_idents`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_sequence_of_custom_idents(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SequenceOfCustomIdents {
+    #[doc = "Calls [Visit`::visit_sequence_of_custom_idents`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_sequence_of_custom_idents(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SequenceOfCustomIdents { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SequenceOfCustomIdents(
-                            self,
-                            self::fields::SequenceOfCustomIdentsField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SequenceOfCustomIdents(
-                            self,
-                            self::fields::SequenceOfCustomIdentsField::Value(usize::MAX),
-                        ));
-                    <Vec<CustomIdent> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<CustomIdent> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SimpleBlock {
-    #[doc = "Calls [VisitAstPath`::visit_simple_block`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_simple_block(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SimpleBlock {
+    #[doc = "Calls [Visit`::visit_simple_block`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_simple_block(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SimpleBlock { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleBlock(
-                        self,
-                        self::fields::SimpleBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleBlock(
-                        self,
-                        self::fields::SimpleBlockField::Name,
-                    ));
-                    <TokenAndSpan as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TokenAndSpan as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleBlock(
-                        self,
-                        self::fields::SimpleBlockField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComponentValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeature {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeature {
+    #[doc = "Calls [Visit`::visit_size_feature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeature::Plain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
-                    self,
-                    self::fields::SizeFeatureField::Plain,
-                ));
-                <SizeFeaturePlain as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeaturePlain as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SizeFeature::Boolean { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
-                    self,
-                    self::fields::SizeFeatureField::Boolean,
-                ));
-                <SizeFeatureBoolean as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeatureBoolean as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SizeFeature::Range { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
-                    self,
-                    self::fields::SizeFeatureField::Range,
-                ));
-                <SizeFeatureRange as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeatureRange as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SizeFeature::RangeInterval { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
-                    self,
-                    self::fields::SizeFeatureField::RangeInterval,
-                ));
-                <SizeFeatureRangeInterval as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeatureRangeInterval as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureBoolean {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature_boolean`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_boolean(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureBoolean {
+    #[doc = "Calls [Visit`::visit_size_feature_boolean`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature_boolean(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeatureBoolean { span, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureBoolean(
-                            self,
-                            self::fields::SizeFeatureBooleanField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureBoolean(
-                            self,
-                            self::fields::SizeFeatureBooleanField::Name,
-                        ));
-                    <SizeFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureName {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureName {
+    #[doc = "Calls [Visit`::visit_size_feature_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeatureName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureName(
-                    self,
-                    self::fields::SizeFeatureNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeaturePlain {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature_plain`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_plain(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeaturePlain {
+    #[doc = "Calls [Visit`::visit_size_feature_plain`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature_plain(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeaturePlain { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeaturePlain(
-                        self,
-                        self::fields::SizeFeaturePlainField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeaturePlain(
-                        self,
-                        self::fields::SizeFeaturePlainField::Name,
-                    ));
-                    <SizeFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeaturePlain(
-                        self,
-                        self::fields::SizeFeaturePlainField::Value,
-                    ));
-                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRange {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature_range`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureRange {
+    #[doc = "Calls [Visit`::visit_size_feature_range`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature_range(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeatureRange {
                 span,
@@ -35352,70 +11000,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRange {
                 right,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
-                        self,
-                        self::fields::SizeFeatureRangeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
-                        self,
-                        self::fields::SizeFeatureRangeField::Left,
-                    ));
-                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
-                        self,
-                        self::fields::SizeFeatureRangeField::Comparison,
-                    ));
-                    <SizeFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
-                        comparison,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureRangeComparison as VisitWith<V>>::visit_with(comparison, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
-                        self,
-                        self::fields::SizeFeatureRangeField::Right,
-                    ));
-                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRangeComparison {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature_range_comparison`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range_comparison(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureRangeComparison {
+    #[doc = "Calls [Visit`::visit_size_feature_range_comparison`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature_range_comparison(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeatureRangeComparison::Lt => {}
             SizeFeatureRangeComparison::Le => {}
@@ -35425,23 +11031,13 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRangeCompariso
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRangeInterval {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature_range_interval`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_range_interval(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureRangeInterval {
+    #[doc = "Calls [Visit`::visit_size_feature_range_interval`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature_range_interval(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeatureRangeInterval {
                 span,
@@ -35452,410 +11048,156 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRangeInterval
                 right,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
-                            self,
-                            self::fields::SizeFeatureRangeIntervalField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
-                            self,
-                            self::fields::SizeFeatureRangeIntervalField::Left,
-                        ));
-                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
-                            self,
-                            self::fields::SizeFeatureRangeIntervalField::LeftComparison,
-                        ));
-                    <SizeFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
+                    <SizeFeatureRangeComparison as VisitWith<V>>::visit_with(
                         left_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
-                            self,
-                            self::fields::SizeFeatureRangeIntervalField::Name,
-                        ));
-                    <SizeFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
-                            self,
-                            self::fields::SizeFeatureRangeIntervalField::RightComparison,
-                        ));
-                    <SizeFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
+                    <SizeFeatureRangeComparison as VisitWith<V>>::visit_with(
                         right_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
-                            self,
-                            self::fields::SizeFeatureRangeIntervalField::Right,
-                        ));
-                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureValue {
-    #[doc = "Calls [VisitAstPath`::visit_size_feature_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_size_feature_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SizeFeatureValue {
+    #[doc = "Calls [Visit`::visit_size_feature_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_size_feature_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SizeFeatureValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
-                    self,
-                    self::fields::SizeFeatureValueField::Number,
-                ));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SizeFeatureValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
-                    self,
-                    self::fields::SizeFeatureValueField::Dimension,
-                ));
-                <Dimension as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Dimension as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SizeFeatureValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
-                    self,
-                    self::fields::SizeFeatureValueField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SizeFeatureValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
-                    self,
-                    self::fields::SizeFeatureValueField::Ratio,
-                ));
-                <Ratio as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ratio as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SizeFeatureValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
-                    self,
-                    self::fields::SizeFeatureValueField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Str {
-    #[doc = "Calls [VisitAstPath`::visit_str`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_str(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Str {
+    #[doc = "Calls [Visit`::visit_str`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_str(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Str { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Value));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Raw));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for StyleBlock {
-    #[doc = "Calls [VisitAstPath`::visit_style_block`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_style_block(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for StyleBlock {
+    #[doc = "Calls [Visit`::visit_style_block`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_style_block(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             StyleBlock::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
-                    self,
-                    self::fields::StyleBlockField::AtRule,
-                ));
-                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             StyleBlock::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
-                    self,
-                    self::fields::StyleBlockField::Declaration,
-                ));
-                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             StyleBlock::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
-                    self,
-                    self::fields::StyleBlockField::QualifiedRule,
-                ));
-                <Box<QualifiedRule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<QualifiedRule> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             StyleBlock::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
-                    self,
-                    self::fields::StyleBlockField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Stylesheet {
-    #[doc = "Calls [VisitAstPath`::visit_stylesheet`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_stylesheet(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Stylesheet {
+    #[doc = "Calls [Visit`::visit_stylesheet`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_stylesheet(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Stylesheet { span, rules } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stylesheet(
-                        self,
-                        self::fields::StylesheetField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stylesheet(
-                        self,
-                        self::fields::StylesheetField::Rules(usize::MAX),
-                    ));
-                    <Vec<Rule> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        rules,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Rule> as VisitWith<V>>::visit_with(rules, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SubclassSelector {
-    #[doc = "Calls [VisitAstPath`::visit_subclass_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_subclass_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SubclassSelector {
+    #[doc = "Calls [Visit`::visit_subclass_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_subclass_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SubclassSelector::Id { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
-                    self,
-                    self::fields::SubclassSelectorField::Id,
-                ));
-                <IdSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SubclassSelector::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
-                    self,
-                    self::fields::SubclassSelectorField::Class,
-                ));
-                <ClassSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SubclassSelector::Attribute { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
-                    self,
-                    self::fields::SubclassSelectorField::Attribute,
-                ));
-                <Box<AttributeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AttributeSelector> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SubclassSelector::PseudoClass { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
-                    self,
-                    self::fields::SubclassSelectorField::PseudoClass,
-                ));
-                <PseudoClassSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PseudoClassSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SubclassSelector::PseudoElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
-                    self,
-                    self::fields::SubclassSelectorField::PseudoElement,
-                ));
-                <PseudoElementSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PseudoElementSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsAnd {
-    #[doc = "Calls [VisitAstPath`::visit_supports_and`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_and(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SupportsAnd {
+    #[doc = "Calls [Visit`::visit_supports_and`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_and(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SupportsAnd {
                 span,
@@ -35863,272 +11205,104 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsAnd {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsAnd(
-                        self,
-                        self::fields::SupportsAndField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsAnd(
-                        self,
-                        self::fields::SupportsAndField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsAnd(
-                        self,
-                        self::fields::SupportsAndField::Condition,
-                    ));
-                    <Box<SupportsInParens> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SupportsInParens> as VisitWith<V>>::visit_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsCondition {
-    #[doc = "Calls [VisitAstPath`::visit_supports_condition`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SupportsCondition {
+    #[doc = "Calls [Visit`::visit_supports_condition`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_condition(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SupportsCondition { span, conditions } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SupportsCondition(
-                            self,
-                            self::fields::SupportsConditionField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::SupportsCondition(
-                            self,
-                            self::fields::SupportsConditionField::Conditions(usize::MAX),
-                        ));
-                    <Vec<SupportsConditionType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<SupportsConditionType> as VisitWith<V>>::visit_with(conditions, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsConditionType {
-    #[doc = "Calls [VisitAstPath`::visit_supports_condition_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_condition_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SupportsConditionType {
+    #[doc = "Calls [Visit`::visit_supports_condition_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_condition_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SupportsConditionType::Not { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
-                        self,
-                        self::fields::SupportsConditionTypeField::Not,
-                    ));
-                <SupportsNot as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            SupportsConditionType::And { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
-                        self,
-                        self::fields::SupportsConditionTypeField::And,
-                    ));
-                <SupportsAnd as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            SupportsConditionType::Or { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
-                        self,
-                        self::fields::SupportsConditionTypeField::Or,
-                    ));
-                <SupportsOr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsNot as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            SupportsConditionType::And { 0: _field_0 } => {
+                <SupportsAnd as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            SupportsConditionType::Or { 0: _field_0 } => {
+                <SupportsOr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SupportsConditionType::SupportsInParens { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
-                        self,
-                        self::fields::SupportsConditionTypeField::SupportsInParens,
-                    ));
-                <SupportsInParens as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsInParens as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsFeature {
-    #[doc = "Calls [VisitAstPath`::visit_supports_feature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_feature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SupportsFeature {
+    #[doc = "Calls [Visit`::visit_supports_feature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_feature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SupportsFeature::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsFeature(
-                    self,
-                    self::fields::SupportsFeatureField::Declaration,
-                ));
-                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SupportsFeature::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsFeature(
-                    self,
-                    self::fields::SupportsFeatureField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsInParens {
-    #[doc = "Calls [VisitAstPath`::visit_supports_in_parens`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SupportsInParens {
+    #[doc = "Calls [Visit`::visit_supports_in_parens`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_in_parens(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SupportsInParens::SupportsCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsInParens(
-                    self,
-                    self::fields::SupportsInParensField::SupportsCondition,
-                ));
-                <SupportsCondition as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsCondition as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SupportsInParens::Feature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsInParens(
-                    self,
-                    self::fields::SupportsInParensField::Feature,
-                ));
-                <SupportsFeature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsFeature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SupportsInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsInParens(
-                    self,
-                    self::fields::SupportsInParensField::GeneralEnclosed,
-                ));
-                <GeneralEnclosed as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GeneralEnclosed as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsNot {
-    #[doc = "Calls [VisitAstPath`::visit_supports_not`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_not(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SupportsNot {
+    #[doc = "Calls [Visit`::visit_supports_not`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_not(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SupportsNot {
                 span,
@@ -36136,59 +11310,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsNot {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsNot(
-                        self,
-                        self::fields::SupportsNotField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsNot(
-                        self,
-                        self::fields::SupportsNotField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsNot(
-                        self,
-                        self::fields::SupportsNotField::Condition,
-                    ));
-                    <Box<SupportsInParens> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SupportsInParens> as VisitWith<V>>::visit_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsOr {
-    #[doc = "Calls [VisitAstPath`::visit_supports_or`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_supports_or(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SupportsOr {
+    #[doc = "Calls [Visit`::visit_supports_or`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_or(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SupportsOr {
                 span,
@@ -36196,459 +11336,166 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsOr {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsOr(
-                        self,
-                        self::fields::SupportsOrField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsOr(
-                        self,
-                        self::fields::SupportsOrField::Keyword,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsOr(
-                        self,
-                        self::fields::SupportsOrField::Condition,
-                    ));
-                    <Box<SupportsInParens> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SupportsInParens> as VisitWith<V>>::visit_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TagNameSelector {
-    #[doc = "Calls [VisitAstPath`::visit_tag_name_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tag_name_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TagNameSelector {
+    #[doc = "Calls [Visit`::visit_tag_name_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_tag_name_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TagNameSelector { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TagNameSelector(
-                        self,
-                        self::fields::TagNameSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TagNameSelector(
-                        self,
-                        self::fields::TagNameSelectorField::Name,
-                    ));
-                    <WqName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <WqName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Time {
-    #[doc = "Calls [VisitAstPath`::visit_time`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_time(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Time {
+    #[doc = "Calls [Visit`::visit_time`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_time(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Time { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Time(self, self::fields::TimeField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Time(self, self::fields::TimeField::Value));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Time(self, self::fields::TimeField::Unit));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TimePercentage {
-    #[doc = "Calls [VisitAstPath`::visit_time_percentage`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_time_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TimePercentage {
+    #[doc = "Calls [Visit`::visit_time_percentage`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_time_percentage(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TimePercentage::Time { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TimePercentage(
-                    self,
-                    self::fields::TimePercentageField::Time,
-                ));
-                <Time as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Time as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TimePercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TimePercentage(
-                    self,
-                    self::fields::TimePercentageField::Percentage,
-                ));
-                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Token {
-    #[doc = "Calls [VisitAstPath`::visit_token`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_token(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Token {
+    #[doc = "Calls [Visit`::visit_token`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_token(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Token::Ident { value, raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::Ident,
-                ));
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::Function { value, raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::Function,
-                ));
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::AtKeyword { value, raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::AtKeyword,
-                ));
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::Hash { is_id, value, raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::Hash,
-                ));
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::String { value, raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::String,
-                ));
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::BadString { raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::BadString,
-                ));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::Url { value, raw } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Url));
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <Box<UrlKeyValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<UrlKeyValue> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::BadUrl { raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::BadUrl,
-                ));
-                {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-            }
-            Token::Delim { value } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::Delim,
-                ));
+                {
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
+                };
             }
+            Token::Delim { value } => {}
             Token::Number {
                 value,
                 raw,
                 type_flag,
             } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::Number,
-                ));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::TypeFlag,
-                    ));
-                    <NumberType as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_flag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <NumberType as VisitWith<V>>::visit_with(type_flag, visitor)
                 };
             }
             Token::Percentage { value, raw } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::Percentage,
-                ));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
             Token::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::Dimension,
-                ));
-                <Box<DimensionToken> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<DimensionToken> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Token::WhiteSpace { value } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                    self,
-                    self::fields::TokenField::WhiteSpace,
-                ));
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
-                        self,
-                        self::fields::TokenField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
             Token::CDO => {}
@@ -36665,111 +11512,49 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Token {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TokenAndSpan {
-    #[doc = "Calls [VisitAstPath`::visit_token_and_span`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_token_and_span(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TokenAndSpan {
+    #[doc = "Calls [Visit`::visit_token_and_span`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_token_and_span(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TokenAndSpan { span, token } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TokenAndSpan(
-                        self,
-                        self::fields::TokenAndSpanField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TokenAndSpan(
-                        self,
-                        self::fields::TokenAndSpanField::Token,
-                    ));
-                    <Token as VisitWithAstPath<V>>::visit_with_ast_path(
-                        token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Token as VisitWith<V>>::visit_with(token, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TypeSelector {
-    #[doc = "Calls [VisitAstPath`::visit_type_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_type_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TypeSelector {
+    #[doc = "Calls [Visit`::visit_type_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_type_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TypeSelector::TagName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TypeSelector(
-                    self,
-                    self::fields::TypeSelectorField::TagName,
-                ));
-                <TagNameSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TagNameSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TypeSelector::Universal { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TypeSelector(
-                    self,
-                    self::fields::TypeSelectorField::Universal,
-                ));
-                <UniversalSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UniversalSelector as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnicodeRange {
-    #[doc = "Calls [VisitAstPath`::visit_unicode_range`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unicode_range(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UnicodeRange {
+    #[doc = "Calls [Visit`::visit_unicode_range`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_unicode_range(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UnicodeRange {
                 span,
@@ -36778,173 +11563,69 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnicodeRange {
                 raw,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
-                        self,
-                        self::fields::UnicodeRangeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
-                        self,
-                        self::fields::UnicodeRangeField::Start,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        start,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(start, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
-                        self,
-                        self::fields::UnicodeRangeField::End,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        end,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(end, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
-                        self,
-                        self::fields::UnicodeRangeField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UniversalSelector {
-    #[doc = "Calls [VisitAstPath`::visit_universal_selector`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_universal_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UniversalSelector {
+    #[doc = "Calls [Visit`::visit_universal_selector`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_universal_selector(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UniversalSelector { span, prefix } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::UniversalSelector(
-                            self,
-                            self::fields::UniversalSelectorField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::UniversalSelector(
-                            self,
-                            self::fields::UniversalSelectorField::Prefix,
-                        ));
-                    <Option<NamespacePrefix> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<NamespacePrefix> as VisitWith<V>>::visit_with(prefix, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnknownDimension {
-    #[doc = "Calls [VisitAstPath`::visit_unknown_dimension`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unknown_dimension(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UnknownDimension {
+    #[doc = "Calls [Visit`::visit_unknown_dimension`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_unknown_dimension(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UnknownDimension { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnknownDimension(
-                        self,
-                        self::fields::UnknownDimensionField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnknownDimension(
-                        self,
-                        self::fields::UnknownDimensionField::Value,
-                    ));
-                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnknownDimension(
-                        self,
-                        self::fields::UnknownDimensionField::Unit,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Url {
-    #[doc = "Calls [VisitAstPath`::visit_url`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Url {
+    #[doc = "Calls [Visit`::visit_url`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_url(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Url {
                 span,
@@ -36953,242 +11634,102 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Url {
                 modifiers,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Url(self, self::fields::UrlField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Url(self, self::fields::UrlField::Name));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Url(self, self::fields::UrlField::Value));
-                    <Option<Box<UrlValue>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<UrlValue>> as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Url(
-                        self,
-                        self::fields::UrlField::Modifiers(usize::MAX),
-                    ));
-                    <Option<Vec<UrlModifier>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        modifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Vec<UrlModifier>> as VisitWith<V>>::visit_with(modifiers, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlKeyValue {
-    #[doc = "Calls [VisitAstPath`::visit_url_key_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_key_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UrlKeyValue {
+    #[doc = "Calls [Visit`::visit_url_key_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_url_key_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UrlKeyValue {
                 0: _field_0,
                 1: _field_1,
             } => {
-                <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_1,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <swc_atoms::Atom as VisitWith<V>>::visit_with(_field_0, visitor);
+                <swc_atoms::Atom as VisitWith<V>>::visit_with(_field_1, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlModifier {
-    #[doc = "Calls [VisitAstPath`::visit_url_modifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_modifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UrlModifier {
+    #[doc = "Calls [Visit`::visit_url_modifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_url_modifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UrlModifier::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlModifier(
-                    self,
-                    self::fields::UrlModifierField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             UrlModifier::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlModifier(
-                    self,
-                    self::fields::UrlModifierField::Function,
-                ));
-                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlValue {
-    #[doc = "Calls [VisitAstPath`::visit_url_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UrlValue {
+    #[doc = "Calls [Visit`::visit_url_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_url_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UrlValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValue(
-                    self,
-                    self::fields::UrlValueField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             UrlValue::Raw { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValue(
-                    self,
-                    self::fields::UrlValueField::Raw,
-                ));
-                <UrlValueRaw as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UrlValueRaw as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlValueRaw {
-    #[doc = "Calls [VisitAstPath`::visit_url_value_raw`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_url_value_raw(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UrlValueRaw {
+    #[doc = "Calls [Visit`::visit_url_value_raw`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_url_value_raw(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UrlValueRaw { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValueRaw(
-                        self,
-                        self::fields::UrlValueRawField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValueRaw(
-                        self,
-                        self::fields::UrlValueRawField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValueRaw(
-                        self,
-                        self::fields::UrlValueRawField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
+                };
+                {
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
+                };
+                {
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WqName {
-    #[doc = "Calls [VisitAstPath`::visit_wq_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_wq_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for WqName {
+    #[doc = "Calls [Visit`::visit_wq_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_wq_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             WqName {
                 span,
@@ -37196,10076 +11737,14378 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WqName {
                 value,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WqName(
-                        self,
-                        self::fields::WqNameField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WqName(
-                        self,
-                        self::fields::WqNameField::Prefix,
-                    ));
-                    <Option<NamespacePrefix> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<NamespacePrefix> as VisitWith<V>>::visit_with(prefix, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WqName(
-                        self,
-                        self::fields::WqNameField::Value,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitAstPath`::visit_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for swc_atoms::Atom {
+    #[doc = "Calls [Visit`::visit_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcProductOrOperator] {
-    #[doc = "Calls [VisitAstPath`::visit_calc_product_or_operators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [CalcProductOrOperator] {
+    #[doc = "Calls [Visit`::visit_calc_product_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_product_or_operators(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_product_or_operators(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CalcProductOrOperator as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <CalcProductOrOperator as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcValueOrOperator] {
-    #[doc = "Calls [VisitAstPath`::visit_calc_value_or_operators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [CalcValueOrOperator] {
+    #[doc = "Calls [Visit`::visit_calc_value_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_calc_value_or_operators(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_calc_value_or_operators(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CalcValueOrOperator as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <CalcValueOrOperator as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelectorChildren] {
-    #[doc = "Calls [VisitAstPath`::visit_complex_selector_childrens`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ComplexSelectorChildren] {
+    #[doc = "Calls [Visit`::visit_complex_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selector_childrens(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_complex_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ComplexSelectorChildren as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ComplexSelectorChildren as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_complex_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ComplexSelector] {
+    #[doc = "Calls [Visit`::visit_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_complex_selectors(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_complex_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ComplexSelector as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComponentValue] {
-    #[doc = "Calls [VisitAstPath`::visit_component_values`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ComponentValue] {
+    #[doc = "Calls [Visit`::visit_component_values`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_component_values(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_component_values(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ComponentValue as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ComponentValue as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CompoundSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_compound_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [CompoundSelector] {
+    #[doc = "Calls [Visit`::visit_compound_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_compound_selectors(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_compound_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <CompoundSelector as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ContainerQueryType] {
-    #[doc = "Calls [VisitAstPath`::visit_container_query_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ContainerQueryType] {
+    #[doc = "Calls [Visit`::visit_container_query_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_container_query_types(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_container_query_types(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ContainerQueryType as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ContainerQueryType as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CustomIdent] {
-    #[doc = "Calls [VisitAstPath`::visit_custom_idents`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [CustomIdent] {
+    #[doc = "Calls [Visit`::visit_custom_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_custom_idents(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_custom_idents(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CustomIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <CustomIdent as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [DocumentPreludeMatchingFunction] {
-    #[doc = "Calls [VisitAstPath`::visit_document_prelude_matching_functions`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [DocumentPreludeMatchingFunction] {
+    #[doc = "Calls [Visit`::visit_document_prelude_matching_functions`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_document_prelude_matching_functions(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_document_prelude_matching_functions(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <DocumentPreludeMatchingFunction as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter().for_each(|item| {
+            <DocumentPreludeMatchingFunction as VisitWith<V>>::visit_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [FamilyName] {
-    #[doc = "Calls [VisitAstPath`::visit_family_names`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [FamilyName] {
+    #[doc = "Calls [Visit`::visit_family_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_family_names(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_family_names(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <FamilyName as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <FamilyName as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingComplexSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_forgiving_complex_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ForgivingComplexSelector] {
+    #[doc = "Calls [Visit`::visit_forgiving_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_complex_selectors(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_forgiving_complex_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ForgivingComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ForgivingComplexSelector as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingRelativeSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_forgiving_relative_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ForgivingRelativeSelector] {
+    #[doc = "Calls [Visit`::visit_forgiving_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_forgiving_relative_selectors(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_forgiving_relative_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ForgivingRelativeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ForgivingRelativeSelector as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [Ident] {
+    #[doc = "Calls [Visit`::visit_idents`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_idents(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Ident as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [KeyframeSelector] {
+    #[doc = "Calls [Visit`::visit_keyframe_selectors`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_keyframe_selectors(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <KeyframeSelector as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [LayerName] {
+    #[doc = "Calls [Visit`::visit_layer_names`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_layer_names(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <LayerName as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [MediaConditionAllType] {
+    #[doc = "Calls [Visit`::visit_media_condition_all_types`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_condition_all_types(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <MediaConditionAllType as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [MediaConditionWithoutOrType] {
+    #[doc = "Calls [Visit`::visit_media_condition_without_or_types`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_condition_without_or_types(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter().for_each(|item| {
+            <MediaConditionWithoutOrType as VisitWith<V>>::visit_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Ident] {
-    #[doc = "Calls [VisitAstPath`::visit_idents`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [MediaQuery] {
+    #[doc = "Calls [Visit`::visit_media_querys`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_media_querys(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <MediaQuery as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<AtRulePrelude>> {
+    #[doc = "Calls [Visit`::visit_opt_at_rule_prelude`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_idents(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_at_rule_prelude(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Ident as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Some(inner) => <Box<AtRulePrelude> as VisitWith<V>>::visit_with(inner, visitor),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [KeyframeSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_keyframe_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [Visit`::visit_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_keyframe_selectors(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <KeyframeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Some(inner) => <swc_atoms::Atom as VisitWith<V>>::visit_with(inner, visitor),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [LayerName] {
-    #[doc = "Calls [VisitAstPath`::visit_layer_names`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorMatcher> {
+    #[doc = "Calls [Visit`::visit_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_layer_names(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_attribute_selector_matcher(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <LayerName as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Some(inner) => <AttributeSelectorMatcher as VisitWith<V>>::visit_with(inner, visitor),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionAllType] {
-    #[doc = "Calls [VisitAstPath`::visit_media_condition_all_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorModifier> {
+    #[doc = "Calls [Visit`::visit_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_all_types(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_attribute_selector_modifier(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <MediaConditionAllType as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Some(inner) => <AttributeSelectorModifier as VisitWith<V>>::visit_with(inner, visitor),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionWithoutOrType] {
-    #[doc = "Calls [VisitAstPath`::visit_media_condition_without_or_types`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorValue> {
+    #[doc = "Calls [Visit`::visit_opt_attribute_selector_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_condition_without_or_types(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_attribute_selector_value(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <MediaConditionWithoutOrType as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Some(inner) => <AttributeSelectorValue as VisitWith<V>>::visit_with(inner, visitor),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaQuery] {
-    #[doc = "Calls [VisitAstPath`::visit_media_querys`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Combinator> {
+    #[doc = "Calls [Visit`::visit_opt_combinator`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_media_querys(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_combinator(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <MediaQuery as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Some(inner) => <Combinator as VisitWith<V>>::visit_with(inner, visitor),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<AtRulePrelude>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_at_rule_prelude`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<ContainerName> {
+    #[doc = "Calls [Visit`::visit_opt_container_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_at_rule_prelude(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_container_name(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<AtRulePrelude> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ContainerName as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<ForgivingSelectorList> {
+    #[doc = "Calls [Visit`::visit_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_forgiving_selector_list(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ForgivingSelectorList as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorMatcher> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Function>> {
+    #[doc = "Calls [Visit`::visit_opt_function`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_matcher(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_function(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <AttributeSelectorMatcher as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<Function> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorModifier> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_attribute_selector_modifier`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Ident> {
+    #[doc = "Calls [Visit`::visit_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_modifier(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ident(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <AttributeSelectorModifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Ident as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorValue> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_attribute_selector_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ImportConditions>> {
+    #[doc = "Calls [Visit`::visit_opt_import_conditions`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_attribute_selector_value(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_import_conditions(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <AttributeSelectorValue as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<ImportConditions> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Combinator> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_combinator`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ImportLayerName>> {
+    #[doc = "Calls [Visit`::visit_opt_import_layer_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_combinator(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_import_layer_name(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Combinator as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Box<ImportLayerName> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ContainerName> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_container_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<ImportantFlag> {
+    #[doc = "Calls [Visit`::visit_opt_important_flag`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_container_name(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_important_flag(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <ContainerName as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ImportantFlag as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ForgivingSelectorList> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<MediaConditionType>> {
+    #[doc = "Calls [Visit`::visit_opt_media_condition_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_forgiving_selector_list(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_media_condition_type(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <ForgivingSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<MediaConditionType> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Function>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_function`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<MediaQueryList>> {
+    #[doc = "Calls [Visit`::visit_opt_media_query_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_function(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_media_query_list(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<MediaQueryList> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ident`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<MediaType> {
+    #[doc = "Calls [Visit`::visit_opt_media_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ident(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_media_type(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <MediaType as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportConditions>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_import_conditions`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Namespace> {
+    #[doc = "Calls [Visit`::visit_opt_namespace`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_import_conditions(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_namespace(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<ImportConditions> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Namespace as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportLayerName>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_import_layer_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<NamespacePrefix> {
+    #[doc = "Calls [Visit`::visit_opt_namespace_prefix`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_import_layer_name(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_namespace_prefix(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<ImportLayerName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <NamespacePrefix as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ImportantFlag> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_important_flag`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<NestingSelector> {
+    #[doc = "Calls [Visit`::visit_opt_nesting_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_important_flag(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_nesting_selector(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <ImportantFlag as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <NestingSelector as VisitWith<V>>::visit_with(inner, visitor),
+            None => {}
+        }
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Number> {
+    #[doc = "Calls [Visit`::visit_opt_number`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_number(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            Some(inner) => <Number as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaConditionType>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_media_condition_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PageSelectorPseudo>> {
+    #[doc = "Calls [Visit`::visit_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_condition_type(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_page_selector_pseudos(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<MediaConditionType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Vec<PageSelectorPseudo> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaQueryList>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_media_query_list`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<PageSelectorType> {
+    #[doc = "Calls [Visit`::visit_opt_page_selector_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_query_list(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_page_selector_type(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<MediaQueryList> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <PageSelectorType as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<MediaType> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_media_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
+    #[doc = "Calls [Visit`::visit_opt_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_media_type(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_pseudo_class_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <MediaType as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+                <Vec<PseudoClassSelectorChildren> as VisitWith<V>>::visit_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_namespace`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
+    #[doc = "Calls [Visit`::visit_opt_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_namespace(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_pseudo_element_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Namespace as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+                <Vec<PseudoElementSelectorChildren> as VisitWith<V>>::visit_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NamespacePrefix> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_namespace_prefix`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<SimpleBlock> {
+    #[doc = "Calls [Visit`::visit_opt_simple_block`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_namespace_prefix(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_simple_block(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <NamespacePrefix as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <SimpleBlock as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NestingSelector> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_nesting_selector`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TypeSelector>> {
+    #[doc = "Calls [Visit`::visit_opt_type_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_nesting_selector(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_type_selector(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <NestingSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<TypeSelector> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Number> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_number`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<UrlModifier>> {
+    #[doc = "Calls [Visit`::visit_opt_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_number(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_url_modifiers(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Vec<UrlModifier> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PageSelectorPseudo>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<UrlValue>> {
+    #[doc = "Calls [Visit`::visit_opt_url_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_page_selector_pseudos(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_url_value(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Vec<PageSelectorPseudo> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<UrlValue> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
+impl<V: ?Sized + Visit> VisitWith<V> for [PageSelectorPseudo] {
+    #[doc = "Calls [Visit`::visit_page_selector_pseudos`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_page_selector_pseudos(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <PageSelectorPseudo as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [PageSelector] {
+    #[doc = "Calls [Visit`::visit_page_selectors`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_page_selectors(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <PageSelector as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [PseudoClassSelectorChildren] {
+    #[doc = "Calls [Visit`::visit_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pseudo_class_selector_childrens(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter().for_each(|item| {
+            <PseudoClassSelectorChildren as VisitWith<V>>::visit_with(item, visitor)
+        })
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [PseudoElementSelectorChildren] {
+    #[doc = "Calls [Visit`::visit_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pseudo_element_selector_childrens(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter().for_each(|item| {
+            <PseudoElementSelectorChildren as VisitWith<V>>::visit_with(item, visitor)
+        })
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [RelativeSelector] {
+    #[doc = "Calls [Visit`::visit_relative_selectors`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_relative_selectors(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <RelativeSelector as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [Rule] {
+    #[doc = "Calls [Visit`::visit_rules`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_rules(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Rule as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for swc_common::Span {
+    #[doc = "Calls [Visit`::visit_span`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_span(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        {}
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [SubclassSelector] {
+    #[doc = "Calls [Visit`::visit_subclass_selectors`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_subclass_selectors(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <SubclassSelector as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [SupportsConditionType] {
+    #[doc = "Calls [Visit`::visit_supports_condition_types`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_supports_condition_types(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <SupportsConditionType as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V: ?Sized + Visit> VisitWith<V> for [UrlModifier] {
+    #[doc = "Calls [Visit`::visit_url_modifiers`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_url_modifiers(visitor, self)
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <UrlModifier as VisitWith<V>>::visit_with(item, visitor))
+    }
+}
+impl<V, T> VisitWith<V> for std::boxed::Box<T>
+where
+    V: ?Sized + Visit,
+    T: VisitWith<V>,
+{
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        let v = <T as VisitWith<V>>::visit_with(&**self, visitor);
+        v
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        let v = <T as VisitWith<V>>::visit_children_with(&**self, visitor);
+        v
+    }
+}
+impl<V, T> VisitWith<V> for std::vec::Vec<T>
+where
+    V: ?Sized + Visit,
+    [T]: VisitWith<V>,
+{
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        let v = <[T] as VisitWith<V>>::visit_with(self, visitor);
+        v
+    }
+
+    #[inline]
+    fn visit_children_with(&self, visitor: &mut V) {
+        let v = <[T] as VisitWith<V>>::visit_children_with(self, visitor);
+        v
+    }
+}
+#[doc = r" A visitor trait for traversing the AST."]
 #[cfg(any(docsrs, feature = "path"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<PageSelectorType> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_page_selector_type`] with `self`. (Extra impl)"]
+pub trait VisitAstPath {
+    #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
+             [`AbsoluteColorBase::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_absolute_color_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AbsoluteColorBase,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_opt_page_selector_type(visitor, self, __ast_path)
+        <AbsoluteColorBase as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
+             [`AlphaValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_alpha_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AlphaValue,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        match self {
-            Some(inner) => <PageSelectorType as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
-            None => {}
-        }
+        <AlphaValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoClassSelectorChildren>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
-             impl)"]
+    #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
+             [`AnPlusB::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_an_plus_b<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusB,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(visitor, self, __ast_path)
+        <AnPlusB as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-
+    #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
+             [`AnPlusBNotation::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusBNotation,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        match self {
-            Some(inner) => {
-                <Vec<PseudoClassSelectorChildren> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
-            }
-            None => {}
-        }
+        <AnPlusBNotation as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoElementSelectorChildren>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_pseudo_element_selector_childrens`] with `self`. \
-             (Extra impl)"]
+    #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
+             [`Angle::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
+        <Angle as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
+    }
+    #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
+             [`AnglePercentage::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
+    #[inline]
+    fn visit_angle_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnglePercentage,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(visitor, self, __ast_path)
+        <AnglePercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
+             [`AnyNamespace::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_any_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnyNamespace,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        match self {
-            Some(inner) => {
-                <Vec<PseudoElementSelectorChildren> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
-            }
-            None => {}
-        }
+        <AnyNamespace as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<SimpleBlock> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_simple_block`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
+             [`AtRule::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRule,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_opt_simple_block(visitor, self, __ast_path)
+        <AtRule as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-
+    #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
+             [`AtRuleName::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_at_rule_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRuleName,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        match self {
-            Some(inner) => <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
-            None => {}
-        }
+        <AtRuleName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TypeSelector>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_type_selector`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
+             [`AtRulePrelude::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRulePrelude,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_opt_type_selector(visitor, self, __ast_path)
+        <AtRulePrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
+             [`swc_atoms :: Atom::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        match self {
-            Some(inner) => <Box<TypeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
-            None => {}
-        }
+        <swc_atoms::Atom as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<UrlModifier>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_url_modifiers`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
+             [`AttributeSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_attribute_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelector,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_opt_url_modifiers(visitor, self, __ast_path)
+        <AttributeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
+             [`AttributeSelectorMatcher::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcher,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        match self {
-            Some(inner) => <Vec<UrlModifier> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
-            None => {}
-        }
+        <AttributeSelectorMatcher as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<UrlValue>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_url_value`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
+             calls [`AttributeSelectorMatcherValue::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcherValue,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_opt_url_value(visitor, self, __ast_path)
+        <AttributeSelectorMatcherValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
+             [`AttributeSelectorModifier::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorModifier,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        match self {
-            Some(inner) => <Box<UrlValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
-            None => {}
-        }
+        <AttributeSelectorModifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelectorPseudo] {
-    #[doc = "Calls [VisitAstPath`::visit_page_selector_pseudos`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
+             [`AttributeSelectorValue::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorValue,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_page_selector_pseudos(visitor, self, __ast_path)
+        <AttributeSelectorValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
+             [`BinOp::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
+        <BinOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
+    }
+    #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
+             [`CalcOperator::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
+    #[inline]
+    fn visit_calc_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperator,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PageSelectorPseudo as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <CalcOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_page_selectors`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
+             [`CalcOperatorType::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_operator_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperatorType,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_page_selectors(visitor, self, __ast_path)
+        <CalcOperatorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
+             [`CalcProduct::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_product<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProduct,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PageSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <CalcProduct as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoClassSelectorChildren] {
-    #[doc = "Calls [VisitAstPath`::visit_pseudo_class_selector_childrens`] with `self`. (Extra \
-             impl)"]
+    #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
+             [`CalcProductOrOperator::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProductOrOperator,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_pseudo_class_selector_childrens(visitor, self, __ast_path)
+        <CalcProductOrOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
+             calls [`Vec < CalcProductOrOperator >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcProductOrOperator],
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PseudoClassSelectorChildren as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <[CalcProductOrOperator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoElementSelectorChildren] {
-    #[doc = "Calls [VisitAstPath`::visit_pseudo_element_selector_childrens`] with `self`. (Extra \
-             impl)"]
+    #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
+             [`CalcSum::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_sum<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcSum,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_pseudo_element_selector_childrens(visitor, self, __ast_path)
+        <CalcSum as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-
+    #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
+             [`CalcValue::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValue,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PseudoElementSelectorChildren as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <CalcValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [RelativeSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_relative_selectors`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
+             [`CalcValueOrOperator::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValueOrOperator,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_relative_selectors(visitor, self, __ast_path)
+        <CalcValueOrOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
+             [`Vec < CalcValueOrOperator >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcValueOrOperator],
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <RelativeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <[CalcValueOrOperator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Rule] {
-    #[doc = "Calls [VisitAstPath`::visit_rules`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
+             [`ClassSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassSelector,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_rules(visitor, self, __ast_path)
+        <ClassSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
+             [`CmykComponent::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_cmyk_component<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CmykComponent,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Rule as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+        <CmykComponent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
-    #[doc = "Calls [VisitAstPath`::visit_span`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
+             [`Color::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
+        <Color as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
+    }
+    #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
+             [`ColorProfileName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
+    #[inline]
+    fn visit_color_profile_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ColorProfileName,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
+        <ColorProfileName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
+             [`Combinator::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Combinator,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        {}
+        <Combinator as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SubclassSelector] {
-    #[doc = "Calls [VisitAstPath`::visit_subclass_selectors`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
+             [`CombinatorValue::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_combinator_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CombinatorValue,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_subclass_selectors(visitor, self, __ast_path)
+        <CombinatorValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
+             [`ComplexSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelector,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <SubclassSelector as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <ComplexSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SupportsConditionType] {
-    #[doc = "Calls [VisitAstPath`::visit_supports_condition_types`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
+             [`ComplexSelectorChildren::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_complex_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelectorChildren,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_supports_condition_types(visitor, self, __ast_path)
+        <ComplexSelectorChildren as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
+             calls [`Vec < ComplexSelectorChildren >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelectorChildren],
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <SupportsConditionType as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <[ComplexSelectorChildren] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [UrlModifier] {
-    #[doc = "Calls [VisitAstPath`::visit_url_modifiers`] with `self`. (Extra impl)"]
+    #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
+             [`Vec < ComplexSelector >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelector],
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitAstPath>::visit_url_modifiers(visitor, self, __ast_path)
+        <[ComplexSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
+             [`ComponentValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_component_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComponentValue,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <UrlModifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+        <ComponentValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> VisitWithAstPath<V> for std::boxed::Box<T>
-where
-    V: ?Sized + VisitAstPath,
-    T: VisitWithAstPath<V>,
-{
+    #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
+             < ComponentValue >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComponentValue],
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        let v = <T as VisitWithAstPath<V>>::visit_with_ast_path(&**self, visitor, __ast_path);
-        v
+        <[ComponentValue] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
+             [`CompoundSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_compound_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelector,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        let v =
-            <T as VisitWithAstPath<V>>::visit_children_with_ast_path(&**self, visitor, __ast_path);
-        v
+        <CompoundSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> VisitWithAstPath<V> for std::vec::Vec<T>
-where
-    V: ?Sized + VisitAstPath,
-    [T]: VisitWithAstPath<V>,
-{
+    #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
+             [`CompoundSelectorList::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_compound_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelectorList,
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        let v = <[T] as VisitWithAstPath<V>>::visit_with_ast_path(self, visitor, __ast_path);
-        v
+        <CompoundSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-
+    #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
+             [`Vec < CompoundSelector >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
+    fn visit_compound_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CompoundSelector],
         __ast_path: &mut AstNodePath<'r>,
     ) {
-        let v =
-            <[T] as VisitWithAstPath<V>>::visit_children_with_ast_path(self, visitor, __ast_path);
-        v
-    }
-}
-#[doc = r" A visitor trait for traversing the AST."]
-pub trait VisitMut {
-    #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
-             [`AbsoluteColorBase::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
-        <AbsoluteColorBase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
-             [`AlphaValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
-        <AlphaValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <[CompoundSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
-             [`AnPlusB::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
+             [`ContainerCondition::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
-        <AnPlusB as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContainerCondition as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
-             [`AnPlusBNotation::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
+             [`ContainerName::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
-        <AnPlusBNotation as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
-             [`Angle::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle) {
-        <Angle as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContainerName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
-             [`AnglePercentage::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
+             [`ContainerQuery::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
-        <AnglePercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
-             [`AnyNamespace::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
-        <AnyNamespace as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContainerQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
-             [`AtRule::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
+             [`ContainerQueryAnd::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
-        <AtRule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_query_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContainerQueryAnd as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
-             [`AtRuleName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
+             [`ContainerQueryNot::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
-        <AtRuleName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_query_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContainerQueryNot as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
-             [`AtRulePrelude::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
+             [`ContainerQueryOr::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
-        <AtRulePrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_query_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContainerQueryOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
+             [`ContainerQueryType::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
-        <swc_atoms::Atom as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_query_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContainerQueryType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
-             [`AttributeSelector::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
+             [`Vec < ContainerQueryType >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
-        <AttributeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_container_query_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ContainerQueryType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ContainerQueryType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
-             [`AttributeSelectorMatcher::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
+             [`CustomHighlightName::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
-        <AttributeSelectorMatcher as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_custom_highlight_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomHighlightName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <CustomHighlightName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
-             calls [`AttributeSelectorMatcherValue::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
+             [`CustomIdent::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector_matcher_value(
+    fn visit_custom_ident<'ast: 'r, 'r>(
         &mut self,
-        node: &mut AttributeSelectorMatcherValue,
+        node: &'ast CustomIdent,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <AttributeSelectorMatcherValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <CustomIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
-             [`AttributeSelectorModifier::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
+             CustomIdent >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
-        <AttributeSelectorModifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CustomIdent],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[CustomIdent] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
-             [`AttributeSelectorValue::visit_mut_children_with`]. If you want to recurse, you need \
+    #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
+             [`CustomMediaQuery::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
-        <AttributeSelectorValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_custom_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <CustomMediaQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
-             [`BinOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
+             [`CustomMediaQueryMediaType::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
-        <BinOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQueryMediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <CustomMediaQueryMediaType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
-             [`CalcOperator::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
+             [`CustomPropertyName::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
-        <CalcOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_custom_property_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomPropertyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <CustomPropertyName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
-             [`CalcOperatorType::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
+             [`DashedIdent::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
-        <CalcOperatorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_dashed_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DashedIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DashedIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
-             [`CalcProduct::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
+             [`Declaration::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
-        <CalcProduct as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_declaration<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Declaration,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Declaration as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
-             [`CalcProductOrOperator::visit_mut_children_with`]. If you want to recurse, you need \
+    #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
+             [`DeclarationName::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
     #[inline]
-    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
-        <CalcProductOrOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
-             calls [`Vec < CalcProductOrOperator >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
-        <Vec<CalcProductOrOperator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_declaration_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DeclarationName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
-             [`CalcSum::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
+             [`DeclarationOrAtRule::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
-        <CalcSum as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationOrAtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DeclarationOrAtRule as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
-             [`CalcValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
+             [`Delimiter::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
-        <CalcValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_delimiter<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Delimiter,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Delimiter as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
-             [`CalcValueOrOperator::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
+             [`DelimiterValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
-        <CalcValueOrOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
-             [`Vec < CalcValueOrOperator >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
-        <Vec<CalcValueOrOperator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_delimiter_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DelimiterValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DelimiterValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
-             [`ClassSelector::visit_mut_children_with`]. If you want to recurse, you need to call \
+    #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
+             [`Dimension::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
-        <ClassSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Dimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Dimension as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
-             [`CmykComponent::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
+             [`DimensionToken::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
-        <CmykComponent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_dimension_token<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DimensionToken,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DimensionToken as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
-             [`Color::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
+             [`DocumentPrelude::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color) {
-        <Color as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_document_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DocumentPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
-             [`ColorProfileName::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
+             calls [`DocumentPreludeMatchingFunction::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
-        <ColorProfileName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DocumentPreludeMatchingFunction as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
-             [`Combinator::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
+             method calls [`Vec < DocumentPreludeMatchingFunction \
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
-        <Combinator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [DocumentPreludeMatchingFunction],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[DocumentPreludeMatchingFunction] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
-             [`CombinatorValue::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
+             [`ExtensionName::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
-        <CombinatorValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_extension_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExtensionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExtensionName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
-             [`ComplexSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
+             [`FamilyName::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
-        <ComplexSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
-             [`ComplexSelectorChildren::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    fn visit_family_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FamilyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <FamilyName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
+    }
+    #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
+             FamilyName >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
-        <ComplexSelectorChildren as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_family_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [FamilyName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[FamilyName] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
-             calls [`Vec < ComplexSelectorChildren >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
+             [`Flex::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
-        <Vec<ComplexSelectorChildren> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
+        <Flex as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
-             [`Vec < ComplexSelector >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
+             [`FontFeatureValuesPrelude::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
-        <Vec<ComplexSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FontFeatureValuesPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <FontFeatureValuesPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
-             [`ComponentValue::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
+             [`ForgivingComplexSelector::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
-        <ComponentValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForgivingComplexSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
-             < ComponentValue >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
+             calls [`Vec < ForgivingComplexSelector >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
-        <Vec<ComponentValue> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ForgivingComplexSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
-             [`CompoundSelector::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
+             [`ForgivingRelativeSelector::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
-        <CompoundSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForgivingRelativeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
-             [`CompoundSelectorList::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+    #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
+             calls [`ForgivingRelativeSelectorList::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
-        <CompoundSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForgivingRelativeSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
-             [`Vec < CompoundSelector >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
+             calls [`Vec < ForgivingRelativeSelector >::visit_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
-        <Vec<CompoundSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingRelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ForgivingRelativeSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
-             [`ContainerCondition::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
+             [`ForgivingSelectorList::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
-        <ContainerCondition as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForgivingSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
-             [`ContainerName::visit_mut_children_with`]. If you want to recurse, you need to call \
+    #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
+             [`Frequency::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
-        <ContainerName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_frequency<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Frequency,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Frequency as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
-             [`ContainerQuery::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
+             [`FrequencyPercentage::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
-        <ContainerQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_frequency_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FrequencyPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <FrequencyPercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
-             [`ContainerQueryAnd::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
+             [`Function::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
-        <ContainerQueryAnd as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Function as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
-             [`ContainerQueryNot::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
+             [`FunctionName::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
-        <ContainerQueryNot as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_function_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FunctionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <FunctionName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
-             [`ContainerQueryOr::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
+             [`GeneralEnclosed::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
-        <ContainerQueryOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_general_enclosed<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast GeneralEnclosed,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <GeneralEnclosed as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
-             [`ContainerQueryType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
+             [`HexColor::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
-        <ContainerQueryType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_hex_color<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast HexColor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <HexColor as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
-             [`Vec < ContainerQueryType >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
+             [`Hue::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
-        <Vec<ContainerQueryType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
+        <Hue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
-             [`CustomHighlightName::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
+             [`IdSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
-        <CustomHighlightName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_id_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <IdSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
-             [`CustomIdent::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
+             [`Ident::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
-        <CustomIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
+        <Ident as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
-             CustomIdent >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
-        <Vec<CustomIdent> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
-             [`CustomMediaQuery::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
-        <CustomMediaQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Ident],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[Ident] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
-             [`CustomMediaQueryMediaType::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
+             [`ImportConditions::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
-        <CustomMediaQueryMediaType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportConditions,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportConditions as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
-             [`CustomPropertyName::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
+             [`ImportHref::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
-        <CustomPropertyName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
-             [`DashedIdent::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
-        <DashedIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_href<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportHref,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportHref as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
-             [`Declaration::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
+             [`ImportLayerName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
-        <Declaration as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportLayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportLayerName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
-             [`DeclarationName::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
+             [`ImportPrelude::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
-        <DeclarationName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
-             [`DeclarationOrAtRule::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
+             [`ImportantFlag::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
-        <DeclarationOrAtRule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_important_flag<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportantFlag,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportantFlag as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
-             [`Delimiter::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
+             [`Integer::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
-        <Delimiter as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_integer<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Integer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Integer as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
-             [`DelimiterValue::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
+             [`KeyframeBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
-        <DelimiterValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_keyframe_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <KeyframeBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
-             [`Dimension::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
+             [`KeyframeSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
-        <Dimension as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_keyframe_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <KeyframeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
-             [`DimensionToken::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
+             [`Vec < KeyframeSelector >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
-        <DimensionToken as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_keyframe_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [KeyframeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[KeyframeSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
-             [`DocumentPrelude::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
+             [`KeyframesName::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
-        <DocumentPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_keyframes_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <KeyframesName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
-             calls [`DocumentPreludeMatchingFunction::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
+             [`KeyframesPseudoFunction::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_document_prelude_matching_function(
+    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
         &mut self,
-        node: &mut DocumentPreludeMatchingFunction,
+        node: &'ast KeyframesPseudoFunction,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <DocumentPreludeMatchingFunction as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <KeyframesPseudoFunction as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
-             method calls [`Vec < DocumentPreludeMatchingFunction >::visit_mut_children_with`]. If \
-             you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
+             [`KeyframesPseudoPrefix::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_document_prelude_matching_functions(
+    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        node: &'ast KeyframesPseudoPrefix,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Vec<DocumentPreludeMatchingFunction> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
+        <KeyframesPseudoPrefix as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
         )
     }
-    #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
-             [`ExtensionName::visit_mut_children_with`]. If you want to recurse, you need to call \
+    #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
+             [`LayerName::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
-        <ExtensionName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <LayerName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
-             [`FamilyName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
+             [`LayerNameList::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
-        <FamilyName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_layer_name_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerNameList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <LayerNameList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
-             FamilyName >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
+             LayerName >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
-        <Vec<FamilyName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_layer_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [LayerName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[LayerName] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
+    }
+    #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
+             [`LayerPrelude::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
+    #[inline]
+    fn visit_layer_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <LayerPrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
-             [`Flex::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
+             [`Length::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex) {
-        <Flex as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
+        <Length as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
-             [`FontFeatureValuesPrelude::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
+             [`LengthPercentage::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
-        <FontFeatureValuesPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_length_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LengthPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <LengthPercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
-             [`ForgivingComplexSelector::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
+             [`ListOfComponentValues::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
-        <ForgivingComplexSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_list_of_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ListOfComponentValues,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ListOfComponentValues as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingComplexSelector >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
+             [`MediaAnd::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
-        <Vec<ForgivingComplexSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaAnd as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
-             [`ForgivingRelativeSelector::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
+             [`MediaCondition::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
-        <ForgivingRelativeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaCondition as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
-             calls [`ForgivingRelativeSelectorList::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
+             [`MediaConditionAllType::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_forgiving_relative_selector_list(
+    fn visit_media_condition_all_type<'ast: 'r, 'r>(
         &mut self,
-        node: &mut ForgivingRelativeSelectorList,
+        node: &'ast MediaConditionAllType,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <ForgivingRelativeSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <MediaConditionAllType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingRelativeSelector >::visit_mut_children_with`]. If you want to \
+    #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
+             calls [`Vec < MediaConditionAllType >::visit_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_forgiving_relative_selectors(
+    fn visit_media_condition_all_types<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<ForgivingRelativeSelector>,
+        node: &'ast [MediaConditionAllType],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Vec<ForgivingRelativeSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
-             [`ForgivingSelectorList::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
-        <ForgivingSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <[MediaConditionAllType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
-             [`Frequency::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
+             [`MediaConditionType::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
-        <Frequency as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaConditionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
-             [`FrequencyPercentage::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
+             [`MediaConditionWithoutOr::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
-        <FrequencyPercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_condition_without_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaConditionWithoutOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
+             [`MediaConditionWithoutOrType::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
-        <Function as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOrType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaConditionWithoutOrType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
-             [`FunctionName::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
+             method calls [`Vec < MediaConditionWithoutOrType >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
-        <FunctionName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionWithoutOrType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[MediaConditionWithoutOrType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
-             [`GeneralEnclosed::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
+             [`MediaFeature::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
-        <GeneralEnclosed as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
-             [`HexColor::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
+             [`MediaFeatureBoolean::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
-        <HexColor as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeatureBoolean as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
-             [`Hue::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
+             [`MediaFeatureName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue) {
-        <Hue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeatureName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
-             [`IdSelector::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
+             [`MediaFeaturePlain::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
-        <IdSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeaturePlain as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
+             [`MediaFeatureRange::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
-        <Ident as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeatureRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
+             [`MediaFeatureRangeComparison::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
-        <Vec<Ident> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeatureRangeComparison as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
-             [`ImportConditions::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
+             [`MediaFeatureRangeInterval::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
-        <ImportConditions as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeatureRangeInterval as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
-             [`ImportHref::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
+             [`MediaFeatureValue::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
-        <ImportHref as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaFeatureValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
-             [`ImportLayerName::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
+             [`MediaInParens::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
-        <ImportLayerName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaInParens as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
-             [`ImportPrelude::visit_mut_children_with`]. If you want to recurse, you need to call \
+    #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
+             [`MediaNot::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
-        <ImportPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaNot as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
-             [`ImportantFlag::visit_mut_children_with`]. If you want to recurse, you need to call \
+    #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
+             [`MediaOr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
-        <ImportantFlag as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
-             [`Integer::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer) {
-        <Integer as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
-             [`KeyframeBlock::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
+             [`MediaQuery::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
-        <KeyframeBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
-             [`KeyframeSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
+             [`MediaQueryList::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
-        <KeyframeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQueryList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaQueryList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
-             [`Vec < KeyframeSelector >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
+             MediaQuery >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
-        <Vec<KeyframeSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_querys<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaQuery],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[MediaQuery] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
-             [`KeyframesName::visit_mut_children_with`]. If you want to recurse, you need to call \
+    #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
+             [`MediaType::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
-        <KeyframesName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MediaType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
-             [`KeyframesPseudoFunction::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
+             [`NamedNamespace::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
-        <KeyframesPseudoFunction as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_named_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NamedNamespace as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
-             [`KeyframesPseudoPrefix::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+    #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
+             [`Namespace::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
-        <KeyframesPseudoPrefix as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Namespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Namespace as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
-             [`LayerName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
+             [`NamespacePrefix::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
-        <LayerName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NamespacePrefix as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
-             [`LayerNameList::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
+             [`NamespacePrelude::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
-        <LayerNameList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_namespace_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NamespacePrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
-             LayerName >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
+             [`NamespacePreludeUri::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
-        <Vec<LayerName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePreludeUri,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NamespacePreludeUri as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
-             [`LayerPrelude::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
+             [`NestingSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
-        <LayerPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NestingSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NestingSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
-             [`Length::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
+             [`Number::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length) {
-        <Length as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
+        <Number as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
-             [`LengthPercentage::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
+             [`NumberType::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
-        <LengthPercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
-             [`ListOfComponentValues::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
-        <ListOfComponentValues as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_number_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NumberType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NumberType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
-             [`MediaAnd::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
+             calls [`Option < Box < AtRulePrelude > >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
-        <MediaAnd as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<AtRulePrelude>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
-             [`MediaCondition::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
+             [`Option < swc_atoms :: Atom >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
-        <MediaCondition as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<swc_atoms::Atom> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
-             [`MediaConditionAllType::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+    #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
+             method calls [`Option < AttributeSelectorMatcher >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
-        <MediaConditionAllType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<AttributeSelectorMatcher> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
-             calls [`Vec < MediaConditionAllType >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
+             method calls [`Option < AttributeSelectorModifier >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
-        <Vec<MediaConditionAllType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<AttributeSelectorModifier> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
-             [`MediaConditionType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
+             calls [`Option < AttributeSelectorValue >::visit_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
-        <MediaConditionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<AttributeSelectorValue> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOr::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
+             [`Option < Combinator >::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
-        <MediaConditionWithoutOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Combinator>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Combinator> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOrType::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
+             [`Option < ContainerName >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_without_or_type(
+    fn visit_opt_container_name<'ast: 'r, 'r>(
         &mut self,
-        node: &mut MediaConditionWithoutOrType,
+        node: &'ast Option<ContainerName>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <MediaConditionWithoutOrType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <Option<ContainerName> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
-             method calls [`Vec < MediaConditionWithoutOrType >::visit_mut_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
+             calls [`Option < ForgivingSelectorList >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_without_or_types(
+    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<MediaConditionWithoutOrType>,
+        node: &'ast Option<ForgivingSelectorList>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Vec<MediaConditionWithoutOrType> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
+        <Option<ForgivingSelectorList> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
         )
     }
-    #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
-             [`MediaFeature::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
+             [`Option < Box < Function > >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
-        <MediaFeature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Function>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<Function>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
-             [`MediaFeatureBoolean::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
+             Ident >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
-        <MediaFeatureBoolean as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Ident> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
-             [`MediaFeatureName::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
+             method calls [`Option < Box < ImportConditions > >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
-        <MediaFeatureName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportConditions>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<ImportConditions>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
-             [`MediaFeaturePlain::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
+             calls [`Option < Box < ImportLayerName > >::visit_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
-        <MediaFeaturePlain as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<ImportLayerName>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
-             [`MediaFeatureRange::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
+             [`Option < ImportantFlag >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
-        <MediaFeatureRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_important_flag<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ImportantFlag>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<ImportantFlag> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeComparison::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
+             method calls [`Option < Box < MediaConditionType > >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
-        <MediaFeatureRangeComparison as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<MediaConditionType>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeInterval::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
+             calls [`Option < Box < MediaQueryList > >::visit_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
-        <MediaFeatureRangeInterval as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<MediaQueryList>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
-             [`MediaFeatureValue::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
+             [`Option < MediaType >::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
-        <MediaFeatureValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<MediaType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<MediaType> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
-             [`MediaInParens::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
+             [`Option < Namespace >::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
-        <MediaInParens as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Namespace>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Namespace> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
-             [`MediaNot::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
+             [`Option < NamespacePrefix >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
-        <MediaNot as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NamespacePrefix>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<NamespacePrefix> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
-             [`MediaOr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
+             [`Option < NestingSelector >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
-        <MediaOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NestingSelector>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<NestingSelector> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
-             [`MediaQuery::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
+             Number >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
-        <MediaQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_number<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Number>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Number> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
-             [`MediaQueryList::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
+             method calls [`Option < Vec < PageSelectorPseudo > >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
-        <MediaQueryList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Vec<PageSelectorPseudo>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
-             MediaQuery >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
+             [`Option < PageSelectorType >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
-        <Vec<MediaQuery> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<PageSelectorType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<PageSelectorType> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
-             [`MediaType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
+             this method calls [`Option < Vec < PseudoClassSelectorChildren > \
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
-        <MediaType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
-             [`NamedNamespace::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
-        <NamedNamespace as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        < Option < Vec < PseudoClassSelectorChildren > > as VisitWithAstPath < Self > > :: visit_children_with_ast_path (node , self , __ast_path)
     }
-    #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
+             default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
-        <Namespace as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        < Option < Vec < PseudoElementSelectorChildren > > as VisitWithAstPath < Self > > :: visit_children_with_ast_path (node , self , __ast_path)
     }
-    #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
-             [`NamespacePrefix::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
+             [`Option < SimpleBlock >::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
-        <NamespacePrefix as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<SimpleBlock>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<SimpleBlock> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
-             [`NamespacePrelude::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
+             calls [`Option < Box < TypeSelector > >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
-        <NamespacePrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TypeSelector>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<TypeSelector>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
-             [`NamespacePreludeUri::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
+             calls [`Option < Vec < UrlModifier > >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
-        <NamespacePreludeUri as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Vec<UrlModifier>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
-             [`NestingSelector::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
+             [`Option < Box < UrlValue > >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
-        <NestingSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<UrlValue>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<UrlValue>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
+             [`PageSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
-        <Number as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_page_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PageSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
-             [`NumberType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
+             [`PageSelectorList::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
-        <NumberType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_page_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PageSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
-             calls [`Option < Box < AtRulePrelude > >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
+             [`PageSelectorPseudo::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
-        <Option<Box<AtRulePrelude>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorPseudo,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PageSelectorPseudo as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_mut_children_with`]. If you want to recurse, \
+    #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
+             [`Vec < PageSelectorPseudo >::visit_children_with_ast_path`]. If you want to recurse, \
              you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
-        <Option<swc_atoms::Atom> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelectorPseudo],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[PageSelectorPseudo] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorMatcher >::visit_mut_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
+             [`PageSelectorType::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_attribute_selector_matcher(
+    fn visit_page_selector_type<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorMatcher>,
+        node: &'ast PageSelectorType,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Option<AttributeSelectorMatcher> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
+        <PageSelectorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
         )
     }
-    #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorModifier >::visit_mut_children_with`]. If \
-             you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
+             PageSelector >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_attribute_selector_modifier(
+    fn visit_page_selectors<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorModifier>,
+        node: &'ast [PageSelector],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Option<AttributeSelectorModifier> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
+        <[PageSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
         )
     }
-    #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
-             calls [`Option < AttributeSelectorValue >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
+             [`Percentage::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_attribute_selector_value(
+    fn visit_percentage<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorValue>,
+        node: &'ast Percentage,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Option<AttributeSelectorValue> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
-             [`Option < Combinator >::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
-        <Option<Combinator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <Percentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
-             [`Option < ContainerName >::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
+             [`PseudoClassSelector::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
-        <Option<ContainerName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PseudoClassSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
-             calls [`Option < ForgivingSelectorList >::visit_mut_children_with`]. If you want to \
+    #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
+             [`PseudoClassSelectorChildren::visit_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
-        <Option<ForgivingSelectorList> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
-             [`Option < Box < Function > >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
-        <Option<Box<Function>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
-        <Option<Ident> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
-             method calls [`Option < Box < ImportConditions > >::visit_mut_children_with`]. If you \
-             want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
-        <Option<Box<ImportConditions>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PseudoClassSelectorChildren as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
-             calls [`Option < Box < ImportLayerName > >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
+             method calls [`Vec < PseudoClassSelectorChildren >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
-        <Option<Box<ImportLayerName>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PseudoClassSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[PseudoClassSelectorChildren] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
-             [`Option < ImportantFlag >::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
+             [`PseudoElementSelector::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
-        <Option<ImportantFlag> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
-             method calls [`Option < Box < MediaConditionType > >::visit_mut_children_with`]. If \
-             you want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
-        <Option<Box<MediaConditionType>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PseudoElementSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
-             calls [`Option < Box < MediaQueryList > >::visit_mut_children_with`]. If you want to \
+    #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
+             calls [`PseudoElementSelectorChildren::visit_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
-        <Option<Box<MediaQueryList>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PseudoElementSelectorChildren as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
-             [`Option < MediaType >::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+    #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
+             method calls [`Vec < PseudoElementSelectorChildren >::visit_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
-        <Option<MediaType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PseudoElementSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[PseudoElementSelectorChildren] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+    #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
+             [`QualifiedRule::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
-        <Option<Namespace> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_qualified_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <QualifiedRule as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
-             [`Option < NamespacePrefix >::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
+             [`QualifiedRulePrelude::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
-        <Option<NamespacePrefix> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <QualifiedRulePrelude as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
-             [`Option < NestingSelector >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
+             [`QueryInParens::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
-        <Option<NestingSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_query_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QueryInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <QueryInParens as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
-             Number >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
+             [`Ratio::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
-        <Option<Number> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
+        <Ratio as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
-             method calls [`Option < Vec < PageSelectorPseudo > >::visit_mut_children_with`]. If \
-             you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
+             [`RelativeSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
-        <Option<Vec<PageSelectorPseudo>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <RelativeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
-             [`Option < PageSelectorType >::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
+             [`RelativeSelectorList::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
-        <Option<PageSelectorType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <RelativeSelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
-             this method calls [`Option < Vec < PseudoClassSelectorChildren > \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
+             [`Vec < RelativeSelector >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_pseudo_class_selector_childrens(
+    fn visit_relative_selectors<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        node: &'ast [RelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Option<Vec<PseudoClassSelectorChildren>> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
+        <[RelativeSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
         )
     }
-    #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
-             default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
+             [`Resolution::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_pseudo_element_selector_childrens(
+    fn visit_resolution<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        node: &'ast Resolution,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Option<Vec<PseudoElementSelectorChildren>> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
-        )
+        <Resolution as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
-             [`Option < SimpleBlock >::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+    #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
+             [`Rule::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
-        <Option<SimpleBlock> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
+        <Rule as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
-             calls [`Option < Box < TypeSelector > >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
-        <Option<Box<TypeSelector>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
+        <[Rule] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
-             calls [`Option < Vec < UrlModifier > >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
+             [`ScopeRange::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
-        <Option<Vec<UrlModifier>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_scope_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ScopeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ScopeRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
-             [`Option < Box < UrlValue > >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
+             [`SelectorList::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
-        <Option<Box<UrlValue>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SelectorList as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
-             [`PageSelector::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
+             [`SequenceOfCustomIdents::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
-        <PageSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SequenceOfCustomIdents,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SequenceOfCustomIdents as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
-             [`PageSelectorList::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
+             [`SimpleBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
-        <PageSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SimpleBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
-             [`PageSelectorPseudo::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
+             [`SizeFeature::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
-        <PageSelectorPseudo as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_size_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SizeFeature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
-             [`Vec < PageSelectorPseudo >::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
+             [`SizeFeatureBoolean::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
-        <Vec<PageSelectorPseudo> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
-             [`PageSelectorType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
-        <PageSelectorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_size_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SizeFeatureBoolean as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
-             PageSelector >::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
+             [`SizeFeatureName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
-        <Vec<PageSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_size_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SizeFeatureName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
-             [`Percentage::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
+             [`SizeFeaturePlain::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
-        <Percentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_size_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SizeFeaturePlain as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
-             [`PseudoClassSelector::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
+             [`SizeFeatureRange::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
-        <PseudoClassSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_size_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SizeFeatureRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
-             [`PseudoClassSelectorChildren::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+    #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
+             [`SizeFeatureRangeComparison::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
-        <PseudoClassSelectorChildren as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SizeFeatureRangeComparison as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoClassSelectorChildren >::visit_mut_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
+             [`SizeFeatureRangeInterval::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_pseudo_class_selector_childrens(
+    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoClassSelectorChildren>,
+        node: &'ast SizeFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Vec<PseudoClassSelectorChildren> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
+        <SizeFeatureRangeInterval as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
         )
     }
-    #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
-             [`PseudoElementSelector::visit_mut_children_with`]. If you want to recurse, you need \
+    #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
+             [`SizeFeatureValue::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
     #[inline]
-    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
-        <PseudoElementSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_size_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SizeFeatureValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
-             calls [`PseudoElementSelectorChildren::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
+             [`swc_common :: Span::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_pseudo_element_selector_children(
+    fn visit_span<'ast: 'r, 'r>(
         &mut self,
-        node: &mut PseudoElementSelectorChildren,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <PseudoElementSelectorChildren as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+        <swc_common::Span as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoElementSelectorChildren >::visit_mut_children_with`]. If \
-             you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
+             [`Str::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
+    #[inline]
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
+        <Str as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
+    }
+    #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
+             [`StyleBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_pseudo_element_selector_childrens(
+    fn visit_style_block<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoElementSelectorChildren>,
+        node: &'ast StyleBlock,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Vec<PseudoElementSelectorChildren> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
-        )
+        <StyleBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
-             [`QualifiedRule::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
+             [`Stylesheet::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
-        <QualifiedRule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_stylesheet<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Stylesheet,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Stylesheet as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
-             [`QualifiedRulePrelude::visit_mut_children_with`]. If you want to recurse, you need \
+    #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
+             [`SubclassSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
     #[inline]
-    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
-        <QualifiedRulePrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
-             [`QueryInParens::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
-        <QueryInParens as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_subclass_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SubclassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SubclassSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
-             [`Ratio::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
+             [`Vec < SubclassSelector >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
-        <Ratio as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_subclass_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SubclassSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[SubclassSelector] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
-             [`RelativeSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
+             [`SupportsAnd::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
-        <RelativeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SupportsAnd as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
-             [`RelativeSelectorList::visit_mut_children_with`]. If you want to recurse, you need \
+    #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
+             [`SupportsCondition::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
     #[inline]
-    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
-        <RelativeSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SupportsCondition as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
-             [`Vec < RelativeSelector >::visit_mut_children_with`]. If you want to recurse, you \
+    #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
+             [`SupportsConditionType::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
     #[inline]
-    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
-        <Vec<RelativeSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SupportsConditionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
-             [`Resolution::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
+             calls [`Vec < SupportsConditionType >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
-        <Resolution as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_condition_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SupportsConditionType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[SupportsConditionType] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
-             [`Rule::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
+             [`SupportsFeature::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule) {
-        <Rule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SupportsFeature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
+             [`SupportsInParens::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
-        <Vec<Rule> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SupportsInParens as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
-             [`ScopeRange::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
+             [`SupportsNot::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
-        <ScopeRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SupportsNot as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
-             [`SelectorList::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+    #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
+             [`SupportsOr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
-        <SelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_supports_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SupportsOr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
-             [`SequenceOfCustomIdents::visit_mut_children_with`]. If you want to recurse, you need \
+    #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
+             [`TagNameSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
-        <SequenceOfCustomIdents as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
-             [`SimpleBlock::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
-        <SimpleBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_tag_name_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TagNameSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TagNameSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
-             [`SizeFeature::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
+             [`Time::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
-        <SizeFeature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
-             [`SizeFeatureBoolean::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
-        <SizeFeatureBoolean as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
+        <Time as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
-             [`SizeFeatureName::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
+             [`TimePercentage::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
-        <SizeFeatureName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_time_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TimePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TimePercentage as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
-             [`SizeFeaturePlain::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
+             [`Token::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
-        <SizeFeaturePlain as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
+        <Token as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
-             [`SizeFeatureRange::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
+             [`TokenAndSpan::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
-        <SizeFeatureRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeComparison::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
-        <SizeFeatureRangeComparison as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeInterval::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
-        <SizeFeatureRangeInterval as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_token_and_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TokenAndSpan,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TokenAndSpan as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
-             [`SizeFeatureValue::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
+             [`TypeSelector::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
-        <SizeFeatureValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TypeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TypeSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
+             [`UnicodeRange::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
-        <swc_common::Span as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_unicode_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnicodeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UnicodeRange as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
+             [`UniversalSelector::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
-        <Str as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_universal_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UniversalSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UniversalSelector as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
-             [`StyleBlock::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
+             [`UnknownDimension::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
-        <StyleBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_unknown_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnknownDimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UnknownDimension as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
-             [`Stylesheet::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
+             [`Url::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
-        <Stylesheet as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
+        <Url as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
-             [`SubclassSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
+             [`UrlKeyValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
-        <SubclassSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
-             [`Vec < SubclassSelector >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
-        <Vec<SubclassSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
-             [`SupportsAnd::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
-        <SupportsAnd as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_url_key_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlKeyValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UrlKeyValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
-             [`SupportsCondition::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
+             [`UrlModifier::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
-        <SupportsCondition as VisitMutWith<Self>>::visit_mut_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
-             [`SupportsConditionType::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
-        <SupportsConditionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_url_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UrlModifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
-             calls [`Vec < SupportsConditionType >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+    #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
+             UrlModifier >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
-        <Vec<SupportsConditionType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [UrlModifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[UrlModifier] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
-             [`SupportsFeature::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+    #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
+             [`UrlValue::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
-        <SupportsFeature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UrlValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
-             [`SupportsInParens::visit_mut_children_with`]. If you want to recurse, you need to \
+    #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
+             [`UrlValueRaw::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
     #[inline]
-    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
-        <SupportsInParens as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_url_value_raw<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValueRaw,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UrlValueRaw as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
-             [`SupportsNot::visit_mut_children_with`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
+             [`WqName::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
-        <SupportsNot as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_wq_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WqName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <WqName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
-             [`SupportsOr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitAstPath for &mut V
+where
+    V: ?Sized + VisitAstPath,
+{
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
-        <SupportsOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_absolute_color_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AbsoluteColorBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_absolute_color_base(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
-             [`TagNameSelector::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+
     #[inline]
-    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
-        <TagNameSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_alpha_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AlphaValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_alpha_value(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
-             [`Time::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time) {
-        <Time as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_an_plus_b<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusB,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_an_plus_b(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
-             [`TimePercentage::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+
     #[inline]
-    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
-        <TimePercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusBNotation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_an_plus_b_notation(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token) {
-        <Token as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_angle(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
-        <TokenAndSpan as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_angle_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnglePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_angle_percentage(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
-             [`TypeSelector::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
-        <TypeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_any_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnyNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_any_namespace(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
-             [`UnicodeRange::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
-        <UnicodeRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
-             [`UniversalSelector::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+
     #[inline]
-    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
-        <UniversalSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_at_rule_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule_name(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
-             [`UnknownDimension::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+
     #[inline]
-    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
-        <UnknownDimension as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule_prelude(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
-             [`Url::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url) {
-        <Url as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
-             [`UrlKeyValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
-        <UrlKeyValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_attribute_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
-             [`UrlModifier::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
-        <UrlModifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcher,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
-             UrlModifier >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
-        <Vec<UrlModifier> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcherValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_matcher_value(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
-             [`UrlValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
-        <UrlValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
-             [`UrlValueRaw::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
-        <UrlValueRaw as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_value(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
-             [`WqName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
-        <WqName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_bin_op(&mut **self, node, __ast_path)
     }
-}
-impl<V> VisitMut for &mut V
-where
-    V: ?Sized + VisitMut,
-{
+
     #[inline]
-    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
-        <V as VisitMut>::visit_mut_absolute_color_base(&mut **self, node)
+    fn visit_calc_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
-        <V as VisitMut>::visit_mut_alpha_value(&mut **self, node)
+    fn visit_calc_operator_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperatorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_operator_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
-        <V as VisitMut>::visit_mut_an_plus_b(&mut **self, node)
+    fn visit_calc_product<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProduct,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
-        <V as VisitMut>::visit_mut_an_plus_b_notation(&mut **self, node)
+    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProductOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle) {
-        <V as VisitMut>::visit_mut_angle(&mut **self, node)
+    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcProductOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
-        <V as VisitMut>::visit_mut_angle_percentage(&mut **self, node)
+    fn visit_calc_sum<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcSum,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_sum(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
-        <V as VisitMut>::visit_mut_any_namespace(&mut **self, node)
+    fn visit_calc_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
-        <V as VisitMut>::visit_mut_at_rule(&mut **self, node)
+    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValueOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
-        <V as VisitMut>::visit_mut_at_rule_name(&mut **self, node)
+    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcValueOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
-        <V as VisitMut>::visit_mut_at_rule_prelude(&mut **self, node)
+    fn visit_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
-        <V as VisitMut>::visit_mut_atom(&mut **self, node)
+    fn visit_cmyk_component<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CmykComponent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_cmyk_component(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
-        <V as VisitMut>::visit_mut_attribute_selector(&mut **self, node)
+    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
-        <V as VisitMut>::visit_mut_attribute_selector_matcher(&mut **self, node)
+    fn visit_color_profile_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ColorProfileName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_color_profile_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher_value(
+    fn visit_combinator<'ast: 'r, 'r>(
         &mut self,
-        node: &mut AttributeSelectorMatcherValue,
+        node: &'ast Combinator,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_attribute_selector_matcher_value(&mut **self, node)
+        <V as VisitAstPath>::visit_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
-        <V as VisitMut>::visit_mut_attribute_selector_modifier(&mut **self, node)
+    fn visit_combinator_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CombinatorValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_combinator_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
-        <V as VisitMut>::visit_mut_attribute_selector_value(&mut **self, node)
+    fn visit_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
-        <V as VisitMut>::visit_mut_bin_op(&mut **self, node)
+    fn visit_complex_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
-        <V as VisitMut>::visit_mut_calc_operator(&mut **self, node)
+    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
-        <V as VisitMut>::visit_mut_calc_operator_type(&mut **self, node)
+    fn visit_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
-        <V as VisitMut>::visit_mut_calc_product(&mut **self, node)
+    fn visit_component_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComponentValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_component_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
-        <V as VisitMut>::visit_mut_calc_product_or_operator(&mut **self, node)
+    fn visit_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComponentValue],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
-        <V as VisitMut>::visit_mut_calc_product_or_operators(&mut **self, node)
+    fn visit_compound_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
-        <V as VisitMut>::visit_mut_calc_sum(&mut **self, node)
+    fn visit_compound_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
-        <V as VisitMut>::visit_mut_calc_value(&mut **self, node)
+    fn visit_compound_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CompoundSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
-        <V as VisitMut>::visit_mut_calc_value_or_operator(&mut **self, node)
+    fn visit_container_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
-        <V as VisitMut>::visit_mut_calc_value_or_operators(&mut **self, node)
+    fn visit_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
-        <V as VisitMut>::visit_mut_class_selector(&mut **self, node)
+    fn visit_container_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
-        <V as VisitMut>::visit_mut_cmyk_component(&mut **self, node)
+    fn visit_container_query_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color) {
-        <V as VisitMut>::visit_mut_color(&mut **self, node)
+    fn visit_container_query_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
-        <V as VisitMut>::visit_mut_color_profile_name(&mut **self, node)
+    fn visit_container_query_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
-        <V as VisitMut>::visit_mut_combinator(&mut **self, node)
+    fn visit_container_query_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
-        <V as VisitMut>::visit_mut_combinator_value(&mut **self, node)
+    fn visit_container_query_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ContainerQueryType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
-        <V as VisitMut>::visit_mut_complex_selector(&mut **self, node)
+    fn visit_custom_highlight_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomHighlightName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_highlight_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
-        <V as VisitMut>::visit_mut_complex_selector_children(&mut **self, node)
+    fn visit_custom_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
-        <V as VisitMut>::visit_mut_complex_selector_childrens(&mut **self, node)
+    fn visit_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CustomIdent],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
-        <V as VisitMut>::visit_mut_complex_selectors(&mut **self, node)
+    fn visit_custom_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
-        <V as VisitMut>::visit_mut_component_value(&mut **self, node)
+    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQueryMediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_media_query_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
-        <V as VisitMut>::visit_mut_component_values(&mut **self, node)
+    fn visit_custom_property_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomPropertyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_property_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
-        <V as VisitMut>::visit_mut_compound_selector(&mut **self, node)
+    fn visit_dashed_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DashedIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dashed_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
-        <V as VisitMut>::visit_mut_compound_selector_list(&mut **self, node)
+    fn visit_declaration<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Declaration,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
-        <V as VisitMut>::visit_mut_compound_selectors(&mut **self, node)
+    fn visit_declaration_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
-        <V as VisitMut>::visit_mut_container_condition(&mut **self, node)
+    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationOrAtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration_or_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
-        <V as VisitMut>::visit_mut_container_name(&mut **self, node)
+    fn visit_delimiter<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Delimiter,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_delimiter(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
-        <V as VisitMut>::visit_mut_container_query(&mut **self, node)
+    fn visit_delimiter_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DelimiterValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_delimiter_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
-        <V as VisitMut>::visit_mut_container_query_and(&mut **self, node)
+    fn visit_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Dimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
-        <V as VisitMut>::visit_mut_container_query_not(&mut **self, node)
+    fn visit_dimension_token<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DimensionToken,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dimension_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
-        <V as VisitMut>::visit_mut_container_query_or(&mut **self, node)
+    fn visit_document_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
-        <V as VisitMut>::visit_mut_container_query_type(&mut **self, node)
+    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude_matching_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
-        <V as VisitMut>::visit_mut_container_query_types(&mut **self, node)
+    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [DocumentPreludeMatchingFunction],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude_matching_functions(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
-        <V as VisitMut>::visit_mut_custom_highlight_name(&mut **self, node)
+    fn visit_extension_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExtensionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_extension_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
-        <V as VisitMut>::visit_mut_custom_ident(&mut **self, node)
+    fn visit_family_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FamilyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_family_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
-        <V as VisitMut>::visit_mut_custom_idents(&mut **self, node)
+    fn visit_family_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [FamilyName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_family_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
-        <V as VisitMut>::visit_mut_custom_media_query(&mut **self, node)
+    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_flex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
-        <V as VisitMut>::visit_mut_custom_media_query_media_type(&mut **self, node)
+    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FontFeatureValuesPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_font_feature_values_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
-        <V as VisitMut>::visit_mut_custom_property_name(&mut **self, node)
+    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
-        <V as VisitMut>::visit_mut_dashed_ident(&mut **self, node)
+    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
-        <V as VisitMut>::visit_mut_declaration(&mut **self, node)
+    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
-        <V as VisitMut>::visit_mut_declaration_name(&mut **self, node)
+    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
-        <V as VisitMut>::visit_mut_declaration_or_at_rule(&mut **self, node)
+    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingRelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
-        <V as VisitMut>::visit_mut_delimiter(&mut **self, node)
+    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
-        <V as VisitMut>::visit_mut_delimiter_value(&mut **self, node)
+    fn visit_frequency<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Frequency,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_frequency(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
-        <V as VisitMut>::visit_mut_dimension(&mut **self, node)
+    fn visit_frequency_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FrequencyPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_frequency_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
-        <V as VisitMut>::visit_mut_dimension_token(&mut **self, node)
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
-        <V as VisitMut>::visit_mut_document_prelude(&mut **self, node)
+    fn visit_function_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FunctionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_function(
+    fn visit_general_enclosed<'ast: 'r, 'r>(
         &mut self,
-        node: &mut DocumentPreludeMatchingFunction,
+        node: &'ast GeneralEnclosed,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_document_prelude_matching_function(&mut **self, node)
+        <V as VisitAstPath>::visit_general_enclosed(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_functions(
+    fn visit_hex_color<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        node: &'ast HexColor,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_document_prelude_matching_functions(&mut **self, node)
+        <V as VisitAstPath>::visit_hex_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
-        <V as VisitMut>::visit_mut_extension_name(&mut **self, node)
+    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_hue(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
-        <V as VisitMut>::visit_mut_family_name(&mut **self, node)
+    fn visit_id_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_id_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
-        <V as VisitMut>::visit_mut_family_names(&mut **self, node)
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex) {
-        <V as VisitMut>::visit_mut_flex(&mut **self, node)
+    fn visit_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Ident],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
-        <V as VisitMut>::visit_mut_font_feature_values_prelude(&mut **self, node)
+    fn visit_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportConditions,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
-        <V as VisitMut>::visit_mut_forgiving_complex_selector(&mut **self, node)
+    fn visit_import_href<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportHref,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_href(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
-        <V as VisitMut>::visit_mut_forgiving_complex_selectors(&mut **self, node)
+    fn visit_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportLayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selector(&mut **self, node)
+    fn visit_import_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector_list(
+    fn visit_important_flag<'ast: 'r, 'r>(
         &mut self,
-        node: &mut ForgivingRelativeSelectorList,
+        node: &'ast ImportantFlag,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selector_list(&mut **self, node)
+        <V as VisitAstPath>::visit_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selectors(
+    fn visit_integer<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<ForgivingRelativeSelector>,
+        node: &'ast Integer,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selectors(&mut **self, node)
+        <V as VisitAstPath>::visit_integer(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
-        <V as VisitMut>::visit_mut_forgiving_selector_list(&mut **self, node)
+    fn visit_keyframe_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
-        <V as VisitMut>::visit_mut_frequency(&mut **self, node)
+    fn visit_keyframe_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
-        <V as VisitMut>::visit_mut_frequency_percentage(&mut **self, node)
+    fn visit_keyframe_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [KeyframeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
-        <V as VisitMut>::visit_mut_function(&mut **self, node)
+    fn visit_keyframes_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
-        <V as VisitMut>::visit_mut_function_name(&mut **self, node)
+    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_pseudo_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
-        <V as VisitMut>::visit_mut_general_enclosed(&mut **self, node)
+    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoPrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
-        <V as VisitMut>::visit_mut_hex_color(&mut **self, node)
+    fn visit_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue) {
-        <V as VisitMut>::visit_mut_hue(&mut **self, node)
+    fn visit_layer_name_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerNameList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_name_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
-        <V as VisitMut>::visit_mut_id_selector(&mut **self, node)
+    fn visit_layer_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [LayerName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
-        <V as VisitMut>::visit_mut_ident(&mut **self, node)
+    fn visit_layer_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
-        <V as VisitMut>::visit_mut_idents(&mut **self, node)
+    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_length(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
-        <V as VisitMut>::visit_mut_import_conditions(&mut **self, node)
+    fn visit_length_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LengthPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_length_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
-        <V as VisitMut>::visit_mut_import_href(&mut **self, node)
+    fn visit_list_of_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ListOfComponentValues,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_list_of_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
-        <V as VisitMut>::visit_mut_import_layer_name(&mut **self, node)
+    fn visit_media_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
-        <V as VisitMut>::visit_mut_import_prelude(&mut **self, node)
+    fn visit_media_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
-        <V as VisitMut>::visit_mut_important_flag(&mut **self, node)
+    fn visit_media_condition_all_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionAllType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_all_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer) {
-        <V as VisitMut>::visit_mut_integer(&mut **self, node)
+    fn visit_media_condition_all_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionAllType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_all_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
-        <V as VisitMut>::visit_mut_keyframe_block(&mut **self, node)
+    fn visit_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
-        <V as VisitMut>::visit_mut_keyframe_selector(&mut **self, node)
+    fn visit_media_condition_without_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
-        <V as VisitMut>::visit_mut_keyframe_selectors(&mut **self, node)
+    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOrType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
-        <V as VisitMut>::visit_mut_keyframes_name(&mut **self, node)
+    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionWithoutOrType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
-        <V as VisitMut>::visit_mut_keyframes_pseudo_function(&mut **self, node)
+    fn visit_media_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
-        <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(&mut **self, node)
+    fn visit_media_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
-        <V as VisitMut>::visit_mut_layer_name(&mut **self, node)
+    fn visit_media_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
-        <V as VisitMut>::visit_mut_layer_name_list(&mut **self, node)
+    fn visit_media_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
-        <V as VisitMut>::visit_mut_layer_names(&mut **self, node)
+    fn visit_media_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
-        <V as VisitMut>::visit_mut_layer_prelude(&mut **self, node)
+    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length) {
-        <V as VisitMut>::visit_mut_length(&mut **self, node)
+    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
-        <V as VisitMut>::visit_mut_length_percentage(&mut **self, node)
+    fn visit_media_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
-        <V as VisitMut>::visit_mut_list_of_component_values(&mut **self, node)
+    fn visit_media_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
-        <V as VisitMut>::visit_mut_media_and(&mut **self, node)
+    fn visit_media_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
-        <V as VisitMut>::visit_mut_media_condition(&mut **self, node)
+    fn visit_media_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
-        <V as VisitMut>::visit_mut_media_condition_all_type(&mut **self, node)
+    fn visit_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
-        <V as VisitMut>::visit_mut_media_condition_all_types(&mut **self, node)
+    fn visit_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQueryList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
-        <V as VisitMut>::visit_mut_media_condition_type(&mut **self, node)
+    fn visit_media_querys<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaQuery],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_querys(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
-        <V as VisitMut>::visit_mut_media_condition_without_or(&mut **self, node)
+    fn visit_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_type(
+    fn visit_named_namespace<'ast: 'r, 'r>(
         &mut self,
-        node: &mut MediaConditionWithoutOrType,
+        node: &'ast NamedNamespace,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_media_condition_without_or_type(&mut **self, node)
+        <V as VisitAstPath>::visit_named_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_types(
+    fn visit_namespace<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<MediaConditionWithoutOrType>,
+        node: &'ast Namespace,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_media_condition_without_or_types(&mut **self, node)
+        <V as VisitAstPath>::visit_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
-        <V as VisitMut>::visit_mut_media_feature(&mut **self, node)
+    fn visit_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
-        <V as VisitMut>::visit_mut_media_feature_boolean(&mut **self, node)
+    fn visit_namespace_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
-        <V as VisitMut>::visit_mut_media_feature_name(&mut **self, node)
+    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePreludeUri,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prelude_uri(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
-        <V as VisitMut>::visit_mut_media_feature_plain(&mut **self, node)
+    fn visit_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NestingSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
-        <V as VisitMut>::visit_mut_media_feature_range(&mut **self, node)
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
-        <V as VisitMut>::visit_mut_media_feature_range_comparison(&mut **self, node)
+    fn visit_number_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NumberType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_number_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
-        <V as VisitMut>::visit_mut_media_feature_range_interval(&mut **self, node)
+    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
-        <V as VisitMut>::visit_mut_media_feature_value(&mut **self, node)
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
-        <V as VisitMut>::visit_mut_media_in_parens(&mut **self, node)
+    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
-        <V as VisitMut>::visit_mut_media_not(&mut **self, node)
+    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
-        <V as VisitMut>::visit_mut_media_or(&mut **self, node)
+    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
-        <V as VisitMut>::visit_mut_media_query(&mut **self, node)
+    fn visit_opt_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Combinator>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
-        <V as VisitMut>::visit_mut_media_query_list(&mut **self, node)
+    fn visit_opt_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ContainerName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
-        <V as VisitMut>::visit_mut_media_querys(&mut **self, node)
+    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ForgivingSelectorList>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
-        <V as VisitMut>::visit_mut_media_type(&mut **self, node)
+    fn visit_opt_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Function>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
-        <V as VisitMut>::visit_mut_named_namespace(&mut **self, node)
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
-        <V as VisitMut>::visit_mut_namespace(&mut **self, node)
+    fn visit_opt_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportConditions>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
-        <V as VisitMut>::visit_mut_namespace_prefix(&mut **self, node)
+    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
-        <V as VisitMut>::visit_mut_namespace_prelude(&mut **self, node)
+    fn visit_opt_important_flag<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ImportantFlag>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
-        <V as VisitMut>::visit_mut_namespace_prelude_uri(&mut **self, node)
+    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
-        <V as VisitMut>::visit_mut_nesting_selector(&mut **self, node)
+    fn visit_opt_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
-        <V as VisitMut>::visit_mut_number(&mut **self, node)
+    fn visit_opt_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<MediaType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
-        <V as VisitMut>::visit_mut_number_type(&mut **self, node)
+    fn visit_opt_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Namespace>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
-        <V as VisitMut>::visit_mut_opt_at_rule_prelude(&mut **self, node)
+    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NamespacePrefix>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
-        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
+    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NestingSelector>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_matcher(
+    fn visit_opt_number<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorMatcher>,
+        node: &'ast Option<Number>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_modifier(
+    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorModifier>,
+        node: &'ast Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_value(
+    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorValue>,
+        node: &'ast Option<PageSelectorType>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_value(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
-        <V as VisitMut>::visit_mut_opt_combinator(&mut **self, node)
+    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
-        <V as VisitMut>::visit_mut_opt_container_name(&mut **self, node)
+    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
-        <V as VisitMut>::visit_mut_opt_forgiving_selector_list(&mut **self, node)
+    fn visit_opt_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<SimpleBlock>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
-        <V as VisitMut>::visit_mut_opt_function(&mut **self, node)
+    fn visit_opt_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TypeSelector>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
-        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
+    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
-        <V as VisitMut>::visit_mut_opt_import_conditions(&mut **self, node)
+    fn visit_opt_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<UrlValue>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
-        <V as VisitMut>::visit_mut_opt_import_layer_name(&mut **self, node)
+    fn visit_page_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
-        <V as VisitMut>::visit_mut_opt_important_flag(&mut **self, node)
+    fn visit_page_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
-        <V as VisitMut>::visit_mut_opt_media_condition_type(&mut **self, node)
+    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorPseudo,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_pseudo(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
-        <V as VisitMut>::visit_mut_opt_media_query_list(&mut **self, node)
+    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelectorPseudo],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
-        <V as VisitMut>::visit_mut_opt_media_type(&mut **self, node)
+    fn visit_page_selector_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
-        <V as VisitMut>::visit_mut_opt_namespace(&mut **self, node)
+    fn visit_page_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
-        <V as VisitMut>::visit_mut_opt_namespace_prefix(&mut **self, node)
+    fn visit_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Percentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
-        <V as VisitMut>::visit_mut_opt_nesting_selector(&mut **self, node)
+    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
-        <V as VisitMut>::visit_mut_opt_number(&mut **self, node)
+    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
-        <V as VisitMut>::visit_mut_opt_page_selector_pseudos(&mut **self, node)
+    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PseudoClassSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
-        <V as VisitMut>::visit_mut_opt_page_selector_type(&mut **self, node)
+    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_element_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_class_selector_childrens(
+    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        node: &'ast PseudoElementSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_pseudo_element_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_element_selector_childrens(
+    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        node: &'ast [PseudoElementSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
-        <V as VisitMut>::visit_mut_opt_simple_block(&mut **self, node)
+    fn visit_qualified_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_qualified_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
-        <V as VisitMut>::visit_mut_opt_type_selector(&mut **self, node)
+    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_qualified_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
-        <V as VisitMut>::visit_mut_opt_url_modifiers(&mut **self, node)
+    fn visit_query_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QueryInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_query_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
-        <V as VisitMut>::visit_mut_opt_url_value(&mut **self, node)
+    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ratio(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
-        <V as VisitMut>::visit_mut_page_selector(&mut **self, node)
+    fn visit_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
-        <V as VisitMut>::visit_mut_page_selector_list(&mut **self, node)
+    fn visit_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
-        <V as VisitMut>::visit_mut_page_selector_pseudo(&mut **self, node)
+    fn visit_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [RelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
-        <V as VisitMut>::visit_mut_page_selector_pseudos(&mut **self, node)
+    fn visit_resolution<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Resolution,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_resolution(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
-        <V as VisitMut>::visit_mut_page_selector_type(&mut **self, node)
+    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
-        <V as VisitMut>::visit_mut_page_selectors(&mut **self, node)
+    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_rules(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
-        <V as VisitMut>::visit_mut_percentage(&mut **self, node)
+    fn visit_scope_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ScopeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_scope_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector(&mut **self, node)
+    fn visit_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector_children(&mut **self, node)
+    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SequenceOfCustomIdents,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_sequence_of_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_childrens(
+    fn visit_simple_block<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoClassSelectorChildren>,
+        node: &'ast SimpleBlock,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector(&mut **self, node)
+    fn visit_size_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_children(
+    fn visit_size_feature_boolean<'ast: 'r, 'r>(
         &mut self,
-        node: &mut PseudoElementSelectorChildren,
+        node: &'ast SizeFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector_children(&mut **self, node)
+        <V as VisitAstPath>::visit_size_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_childrens(
+    fn visit_size_feature_name<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoElementSelectorChildren>,
+        node: &'ast SizeFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_size_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
-        <V as VisitMut>::visit_mut_qualified_rule(&mut **self, node)
+    fn visit_size_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
-        <V as VisitMut>::visit_mut_qualified_rule_prelude(&mut **self, node)
+    fn visit_size_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
-        <V as VisitMut>::visit_mut_query_in_parens(&mut **self, node)
+    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
-        <V as VisitMut>::visit_mut_ratio(&mut **self, node)
+    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
-        <V as VisitMut>::visit_mut_relative_selector(&mut **self, node)
+    fn visit_size_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
-        <V as VisitMut>::visit_mut_relative_selector_list(&mut **self, node)
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
-        <V as VisitMut>::visit_mut_relative_selectors(&mut **self, node)
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
-        <V as VisitMut>::visit_mut_resolution(&mut **self, node)
+    fn visit_style_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StyleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_style_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule) {
-        <V as VisitMut>::visit_mut_rule(&mut **self, node)
+    fn visit_stylesheet<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Stylesheet,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_stylesheet(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
-        <V as VisitMut>::visit_mut_rules(&mut **self, node)
+    fn visit_subclass_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SubclassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_subclass_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
-        <V as VisitMut>::visit_mut_scope_range(&mut **self, node)
+    fn visit_subclass_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SubclassSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_subclass_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
-        <V as VisitMut>::visit_mut_selector_list(&mut **self, node)
+    fn visit_supports_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
-        <V as VisitMut>::visit_mut_sequence_of_custom_idents(&mut **self, node)
+    fn visit_supports_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
-        <V as VisitMut>::visit_mut_simple_block(&mut **self, node)
+    fn visit_supports_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
-        <V as VisitMut>::visit_mut_size_feature(&mut **self, node)
+    fn visit_supports_condition_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SupportsConditionType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
-        <V as VisitMut>::visit_mut_size_feature_boolean(&mut **self, node)
+    fn visit_supports_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
-        <V as VisitMut>::visit_mut_size_feature_name(&mut **self, node)
+    fn visit_supports_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
-        <V as VisitMut>::visit_mut_size_feature_plain(&mut **self, node)
+    fn visit_supports_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
-        <V as VisitMut>::visit_mut_size_feature_range(&mut **self, node)
+    fn visit_supports_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
-        <V as VisitMut>::visit_mut_size_feature_range_comparison(&mut **self, node)
+    fn visit_tag_name_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TagNameSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tag_name_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
-        <V as VisitMut>::visit_mut_size_feature_range_interval(&mut **self, node)
+    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_time(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
-        <V as VisitMut>::visit_mut_size_feature_value(&mut **self, node)
+    fn visit_time_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TimePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_time_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
-        <V as VisitMut>::visit_mut_span(&mut **self, node)
+    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
-        <V as VisitMut>::visit_mut_str(&mut **self, node)
+    fn visit_token_and_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TokenAndSpan,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_token_and_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
-        <V as VisitMut>::visit_mut_style_block(&mut **self, node)
+    fn visit_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TypeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
-        <V as VisitMut>::visit_mut_stylesheet(&mut **self, node)
+    fn visit_unicode_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnicodeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unicode_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
-        <V as VisitMut>::visit_mut_subclass_selector(&mut **self, node)
+    fn visit_universal_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UniversalSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_universal_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
-        <V as VisitMut>::visit_mut_subclass_selectors(&mut **self, node)
+    fn visit_unknown_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnknownDimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unknown_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
-        <V as VisitMut>::visit_mut_supports_and(&mut **self, node)
+    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_url(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
-        <V as VisitMut>::visit_mut_supports_condition(&mut **self, node)
+    fn visit_url_key_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlKeyValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_key_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
-        <V as VisitMut>::visit_mut_supports_condition_type(&mut **self, node)
+    fn visit_url_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
-        <V as VisitMut>::visit_mut_supports_condition_types(&mut **self, node)
+    fn visit_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [UrlModifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
-        <V as VisitMut>::visit_mut_supports_feature(&mut **self, node)
+    fn visit_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
-        <V as VisitMut>::visit_mut_supports_in_parens(&mut **self, node)
+    fn visit_url_value_raw<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValueRaw,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_value_raw(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
-        <V as VisitMut>::visit_mut_supports_not(&mut **self, node)
+    fn visit_wq_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WqName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_wq_name(&mut **self, node, __ast_path)
     }
-
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitAstPath for Box<V>
+where
+    V: ?Sized + VisitAstPath,
+{
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
-        <V as VisitMut>::visit_mut_supports_or(&mut **self, node)
+    fn visit_absolute_color_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AbsoluteColorBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_absolute_color_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
-        <V as VisitMut>::visit_mut_tag_name_selector(&mut **self, node)
+    fn visit_alpha_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AlphaValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_alpha_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time) {
-        <V as VisitMut>::visit_mut_time(&mut **self, node)
+    fn visit_an_plus_b<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusB,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_an_plus_b(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
-        <V as VisitMut>::visit_mut_time_percentage(&mut **self, node)
+    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusBNotation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_an_plus_b_notation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token) {
-        <V as VisitMut>::visit_mut_token(&mut **self, node)
+    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_angle(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
-        <V as VisitMut>::visit_mut_token_and_span(&mut **self, node)
+    fn visit_angle_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnglePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_angle_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
-        <V as VisitMut>::visit_mut_type_selector(&mut **self, node)
+    fn visit_any_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnyNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_any_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
-        <V as VisitMut>::visit_mut_unicode_range(&mut **self, node)
+    fn visit_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
-        <V as VisitMut>::visit_mut_universal_selector(&mut **self, node)
+    fn visit_at_rule_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
-        <V as VisitMut>::visit_mut_unknown_dimension(&mut **self, node)
+    fn visit_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url) {
-        <V as VisitMut>::visit_mut_url(&mut **self, node)
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
-        <V as VisitMut>::visit_mut_url_key_value(&mut **self, node)
+    fn visit_attribute_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
-        <V as VisitMut>::visit_mut_url_modifier(&mut **self, node)
+    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcher,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
-        <V as VisitMut>::visit_mut_url_modifiers(&mut **self, node)
+    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcherValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_matcher_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
-        <V as VisitMut>::visit_mut_url_value(&mut **self, node)
+    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
-        <V as VisitMut>::visit_mut_url_value_raw(&mut **self, node)
+    fn visit_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
-        <V as VisitMut>::visit_mut_wq_name(&mut **self, node)
+    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_bin_op(&mut **self, node, __ast_path)
     }
-}
-impl<V> VisitMut for Box<V>
-where
-    V: ?Sized + VisitMut,
-{
+
     #[inline]
-    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
-        <V as VisitMut>::visit_mut_absolute_color_base(&mut **self, node)
+    fn visit_calc_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
-        <V as VisitMut>::visit_mut_alpha_value(&mut **self, node)
+    fn visit_calc_operator_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperatorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_operator_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
-        <V as VisitMut>::visit_mut_an_plus_b(&mut **self, node)
+    fn visit_calc_product<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProduct,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
-        <V as VisitMut>::visit_mut_an_plus_b_notation(&mut **self, node)
+    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProductOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle) {
-        <V as VisitMut>::visit_mut_angle(&mut **self, node)
+    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcProductOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
-        <V as VisitMut>::visit_mut_angle_percentage(&mut **self, node)
+    fn visit_calc_sum<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcSum,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_sum(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
-        <V as VisitMut>::visit_mut_any_namespace(&mut **self, node)
+    fn visit_calc_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
-        <V as VisitMut>::visit_mut_at_rule(&mut **self, node)
+    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValueOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
-        <V as VisitMut>::visit_mut_at_rule_name(&mut **self, node)
+    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcValueOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
-        <V as VisitMut>::visit_mut_at_rule_prelude(&mut **self, node)
+    fn visit_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
-        <V as VisitMut>::visit_mut_atom(&mut **self, node)
+    fn visit_cmyk_component<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CmykComponent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_cmyk_component(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
-        <V as VisitMut>::visit_mut_attribute_selector(&mut **self, node)
+    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
-        <V as VisitMut>::visit_mut_attribute_selector_matcher(&mut **self, node)
+    fn visit_color_profile_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ColorProfileName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_color_profile_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher_value(
+    fn visit_combinator<'ast: 'r, 'r>(
         &mut self,
-        node: &mut AttributeSelectorMatcherValue,
+        node: &'ast Combinator,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_attribute_selector_matcher_value(&mut **self, node)
+        <V as VisitAstPath>::visit_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
-        <V as VisitMut>::visit_mut_attribute_selector_modifier(&mut **self, node)
+    fn visit_combinator_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CombinatorValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_combinator_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
-        <V as VisitMut>::visit_mut_attribute_selector_value(&mut **self, node)
+    fn visit_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
-        <V as VisitMut>::visit_mut_bin_op(&mut **self, node)
+    fn visit_complex_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
-        <V as VisitMut>::visit_mut_calc_operator(&mut **self, node)
+    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
-        <V as VisitMut>::visit_mut_calc_operator_type(&mut **self, node)
+    fn visit_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
-        <V as VisitMut>::visit_mut_calc_product(&mut **self, node)
+    fn visit_component_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComponentValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_component_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
-        <V as VisitMut>::visit_mut_calc_product_or_operator(&mut **self, node)
+    fn visit_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComponentValue],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
-        <V as VisitMut>::visit_mut_calc_product_or_operators(&mut **self, node)
+    fn visit_compound_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
-        <V as VisitMut>::visit_mut_calc_sum(&mut **self, node)
+    fn visit_compound_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
-        <V as VisitMut>::visit_mut_calc_value(&mut **self, node)
+    fn visit_compound_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CompoundSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
-        <V as VisitMut>::visit_mut_calc_value_or_operator(&mut **self, node)
+    fn visit_container_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
-        <V as VisitMut>::visit_mut_calc_value_or_operators(&mut **self, node)
+    fn visit_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
-        <V as VisitMut>::visit_mut_class_selector(&mut **self, node)
+    fn visit_container_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
-        <V as VisitMut>::visit_mut_cmyk_component(&mut **self, node)
+    fn visit_container_query_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color) {
-        <V as VisitMut>::visit_mut_color(&mut **self, node)
+    fn visit_container_query_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
-        <V as VisitMut>::visit_mut_color_profile_name(&mut **self, node)
+    fn visit_container_query_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
-        <V as VisitMut>::visit_mut_combinator(&mut **self, node)
+    fn visit_container_query_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
-        <V as VisitMut>::visit_mut_combinator_value(&mut **self, node)
+    fn visit_container_query_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ContainerQueryType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
-        <V as VisitMut>::visit_mut_complex_selector(&mut **self, node)
+    fn visit_custom_highlight_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomHighlightName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_highlight_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
-        <V as VisitMut>::visit_mut_complex_selector_children(&mut **self, node)
+    fn visit_custom_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
-        <V as VisitMut>::visit_mut_complex_selector_childrens(&mut **self, node)
+    fn visit_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CustomIdent],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
-        <V as VisitMut>::visit_mut_complex_selectors(&mut **self, node)
+    fn visit_custom_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
-        <V as VisitMut>::visit_mut_component_value(&mut **self, node)
+    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQueryMediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_media_query_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
-        <V as VisitMut>::visit_mut_component_values(&mut **self, node)
+    fn visit_custom_property_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomPropertyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_property_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
-        <V as VisitMut>::visit_mut_compound_selector(&mut **self, node)
+    fn visit_dashed_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DashedIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dashed_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
-        <V as VisitMut>::visit_mut_compound_selector_list(&mut **self, node)
+    fn visit_declaration<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Declaration,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
-        <V as VisitMut>::visit_mut_compound_selectors(&mut **self, node)
+    fn visit_declaration_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
-        <V as VisitMut>::visit_mut_container_condition(&mut **self, node)
+    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationOrAtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration_or_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
-        <V as VisitMut>::visit_mut_container_name(&mut **self, node)
+    fn visit_delimiter<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Delimiter,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_delimiter(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
-        <V as VisitMut>::visit_mut_container_query(&mut **self, node)
+    fn visit_delimiter_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DelimiterValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_delimiter_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
-        <V as VisitMut>::visit_mut_container_query_and(&mut **self, node)
+    fn visit_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Dimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
-        <V as VisitMut>::visit_mut_container_query_not(&mut **self, node)
+    fn visit_dimension_token<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DimensionToken,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dimension_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
-        <V as VisitMut>::visit_mut_container_query_or(&mut **self, node)
+    fn visit_document_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
-        <V as VisitMut>::visit_mut_container_query_type(&mut **self, node)
+    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude_matching_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
-        <V as VisitMut>::visit_mut_container_query_types(&mut **self, node)
+    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [DocumentPreludeMatchingFunction],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude_matching_functions(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
-        <V as VisitMut>::visit_mut_custom_highlight_name(&mut **self, node)
+    fn visit_extension_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExtensionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_extension_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
-        <V as VisitMut>::visit_mut_custom_ident(&mut **self, node)
+    fn visit_family_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FamilyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_family_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
-        <V as VisitMut>::visit_mut_custom_idents(&mut **self, node)
+    fn visit_family_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [FamilyName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_family_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
-        <V as VisitMut>::visit_mut_custom_media_query(&mut **self, node)
+    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_flex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
-        <V as VisitMut>::visit_mut_custom_media_query_media_type(&mut **self, node)
+    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FontFeatureValuesPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_font_feature_values_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
-        <V as VisitMut>::visit_mut_custom_property_name(&mut **self, node)
+    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
-        <V as VisitMut>::visit_mut_dashed_ident(&mut **self, node)
+    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
-        <V as VisitMut>::visit_mut_declaration(&mut **self, node)
+    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
-        <V as VisitMut>::visit_mut_declaration_name(&mut **self, node)
+    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
-        <V as VisitMut>::visit_mut_declaration_or_at_rule(&mut **self, node)
+    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingRelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
-        <V as VisitMut>::visit_mut_delimiter(&mut **self, node)
+    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
-        <V as VisitMut>::visit_mut_delimiter_value(&mut **self, node)
+    fn visit_frequency<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Frequency,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_frequency(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
-        <V as VisitMut>::visit_mut_dimension(&mut **self, node)
+    fn visit_frequency_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FrequencyPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_frequency_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
-        <V as VisitMut>::visit_mut_dimension_token(&mut **self, node)
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
-        <V as VisitMut>::visit_mut_document_prelude(&mut **self, node)
+    fn visit_function_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FunctionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_function(
+    fn visit_general_enclosed<'ast: 'r, 'r>(
         &mut self,
-        node: &mut DocumentPreludeMatchingFunction,
+        node: &'ast GeneralEnclosed,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_document_prelude_matching_function(&mut **self, node)
+        <V as VisitAstPath>::visit_general_enclosed(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_functions(
+    fn visit_hex_color<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        node: &'ast HexColor,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_document_prelude_matching_functions(&mut **self, node)
+        <V as VisitAstPath>::visit_hex_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
-        <V as VisitMut>::visit_mut_extension_name(&mut **self, node)
+    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_hue(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
-        <V as VisitMut>::visit_mut_family_name(&mut **self, node)
+    fn visit_id_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_id_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
-        <V as VisitMut>::visit_mut_family_names(&mut **self, node)
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex) {
-        <V as VisitMut>::visit_mut_flex(&mut **self, node)
+    fn visit_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Ident],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
-        <V as VisitMut>::visit_mut_font_feature_values_prelude(&mut **self, node)
+    fn visit_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportConditions,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
-        <V as VisitMut>::visit_mut_forgiving_complex_selector(&mut **self, node)
+    fn visit_import_href<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportHref,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_href(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
-        <V as VisitMut>::visit_mut_forgiving_complex_selectors(&mut **self, node)
+    fn visit_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportLayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selector(&mut **self, node)
+    fn visit_import_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector_list(
+    fn visit_important_flag<'ast: 'r, 'r>(
         &mut self,
-        node: &mut ForgivingRelativeSelectorList,
+        node: &'ast ImportantFlag,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selector_list(&mut **self, node)
+        <V as VisitAstPath>::visit_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selectors(
+    fn visit_integer<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<ForgivingRelativeSelector>,
+        node: &'ast Integer,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selectors(&mut **self, node)
+        <V as VisitAstPath>::visit_integer(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
-        <V as VisitMut>::visit_mut_forgiving_selector_list(&mut **self, node)
+    fn visit_keyframe_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
-        <V as VisitMut>::visit_mut_frequency(&mut **self, node)
+    fn visit_keyframe_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
-        <V as VisitMut>::visit_mut_frequency_percentage(&mut **self, node)
+    fn visit_keyframe_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [KeyframeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
-        <V as VisitMut>::visit_mut_function(&mut **self, node)
+    fn visit_keyframes_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
-        <V as VisitMut>::visit_mut_function_name(&mut **self, node)
+    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_pseudo_function(&mut **self, node, __ast_path)
+    }
+
+    #[inline]
+    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoPrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
-        <V as VisitMut>::visit_mut_general_enclosed(&mut **self, node)
+    fn visit_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
-        <V as VisitMut>::visit_mut_hex_color(&mut **self, node)
+    fn visit_layer_name_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerNameList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_name_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue) {
-        <V as VisitMut>::visit_mut_hue(&mut **self, node)
+    fn visit_layer_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [LayerName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
-        <V as VisitMut>::visit_mut_id_selector(&mut **self, node)
+    fn visit_layer_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
-        <V as VisitMut>::visit_mut_ident(&mut **self, node)
+    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_length(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
-        <V as VisitMut>::visit_mut_idents(&mut **self, node)
+    fn visit_length_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LengthPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_length_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
-        <V as VisitMut>::visit_mut_import_conditions(&mut **self, node)
+    fn visit_list_of_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ListOfComponentValues,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_list_of_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
-        <V as VisitMut>::visit_mut_import_href(&mut **self, node)
+    fn visit_media_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
-        <V as VisitMut>::visit_mut_import_layer_name(&mut **self, node)
+    fn visit_media_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
-        <V as VisitMut>::visit_mut_import_prelude(&mut **self, node)
+    fn visit_media_condition_all_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionAllType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_all_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
-        <V as VisitMut>::visit_mut_important_flag(&mut **self, node)
+    fn visit_media_condition_all_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionAllType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_all_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer) {
-        <V as VisitMut>::visit_mut_integer(&mut **self, node)
+    fn visit_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
-        <V as VisitMut>::visit_mut_keyframe_block(&mut **self, node)
+    fn visit_media_condition_without_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
-        <V as VisitMut>::visit_mut_keyframe_selector(&mut **self, node)
+    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOrType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
-        <V as VisitMut>::visit_mut_keyframe_selectors(&mut **self, node)
+    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionWithoutOrType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
-        <V as VisitMut>::visit_mut_keyframes_name(&mut **self, node)
+    fn visit_media_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
-        <V as VisitMut>::visit_mut_keyframes_pseudo_function(&mut **self, node)
+    fn visit_media_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
-        <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(&mut **self, node)
+    fn visit_media_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
-        <V as VisitMut>::visit_mut_layer_name(&mut **self, node)
+    fn visit_media_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
-        <V as VisitMut>::visit_mut_layer_name_list(&mut **self, node)
+    fn visit_media_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
-        <V as VisitMut>::visit_mut_layer_names(&mut **self, node)
+    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
-        <V as VisitMut>::visit_mut_layer_prelude(&mut **self, node)
+    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length) {
-        <V as VisitMut>::visit_mut_length(&mut **self, node)
+    fn visit_media_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
-        <V as VisitMut>::visit_mut_length_percentage(&mut **self, node)
+    fn visit_media_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
-        <V as VisitMut>::visit_mut_list_of_component_values(&mut **self, node)
+    fn visit_media_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
-        <V as VisitMut>::visit_mut_media_and(&mut **self, node)
+    fn visit_media_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
-        <V as VisitMut>::visit_mut_media_condition(&mut **self, node)
+    fn visit_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
-        <V as VisitMut>::visit_mut_media_condition_all_type(&mut **self, node)
+    fn visit_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQueryList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
-        <V as VisitMut>::visit_mut_media_condition_all_types(&mut **self, node)
+    fn visit_media_querys<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaQuery],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_querys(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
-        <V as VisitMut>::visit_mut_media_condition_type(&mut **self, node)
+    fn visit_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
-        <V as VisitMut>::visit_mut_media_condition_without_or(&mut **self, node)
+    fn visit_named_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_named_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_type(
+    fn visit_namespace<'ast: 'r, 'r>(
         &mut self,
-        node: &mut MediaConditionWithoutOrType,
+        node: &'ast Namespace,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_media_condition_without_or_type(&mut **self, node)
+        <V as VisitAstPath>::visit_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_types(
+    fn visit_namespace_prefix<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<MediaConditionWithoutOrType>,
+        node: &'ast NamespacePrefix,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_media_condition_without_or_types(&mut **self, node)
+        <V as VisitAstPath>::visit_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
-        <V as VisitMut>::visit_mut_media_feature(&mut **self, node)
+    fn visit_namespace_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
-        <V as VisitMut>::visit_mut_media_feature_boolean(&mut **self, node)
+    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePreludeUri,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prelude_uri(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
-        <V as VisitMut>::visit_mut_media_feature_name(&mut **self, node)
+    fn visit_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NestingSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
-        <V as VisitMut>::visit_mut_media_feature_plain(&mut **self, node)
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
-        <V as VisitMut>::visit_mut_media_feature_range(&mut **self, node)
+    fn visit_number_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NumberType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_number_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
-        <V as VisitMut>::visit_mut_media_feature_range_comparison(&mut **self, node)
+    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
-        <V as VisitMut>::visit_mut_media_feature_range_interval(&mut **self, node)
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
-        <V as VisitMut>::visit_mut_media_feature_value(&mut **self, node)
+    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
-        <V as VisitMut>::visit_mut_media_in_parens(&mut **self, node)
+    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
-        <V as VisitMut>::visit_mut_media_not(&mut **self, node)
+    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
-        <V as VisitMut>::visit_mut_media_or(&mut **self, node)
+    fn visit_opt_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Combinator>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
-        <V as VisitMut>::visit_mut_media_query(&mut **self, node)
+    fn visit_opt_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ContainerName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
-        <V as VisitMut>::visit_mut_media_query_list(&mut **self, node)
+    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ForgivingSelectorList>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
-        <V as VisitMut>::visit_mut_media_querys(&mut **self, node)
+    fn visit_opt_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Function>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
-        <V as VisitMut>::visit_mut_media_type(&mut **self, node)
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
-        <V as VisitMut>::visit_mut_named_namespace(&mut **self, node)
+    fn visit_opt_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportConditions>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
-        <V as VisitMut>::visit_mut_namespace(&mut **self, node)
+    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
-        <V as VisitMut>::visit_mut_namespace_prefix(&mut **self, node)
+    fn visit_opt_important_flag<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ImportantFlag>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
-        <V as VisitMut>::visit_mut_namespace_prelude(&mut **self, node)
+    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
-        <V as VisitMut>::visit_mut_namespace_prelude_uri(&mut **self, node)
+    fn visit_opt_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
-        <V as VisitMut>::visit_mut_nesting_selector(&mut **self, node)
+    fn visit_opt_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<MediaType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
-        <V as VisitMut>::visit_mut_number(&mut **self, node)
+    fn visit_opt_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Namespace>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
-        <V as VisitMut>::visit_mut_number_type(&mut **self, node)
+    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NamespacePrefix>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
-        <V as VisitMut>::visit_mut_opt_at_rule_prelude(&mut **self, node)
+    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NestingSelector>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
-        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
+    fn visit_opt_number<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Number>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_matcher(
+    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorMatcher>,
+        node: &'ast Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_modifier(
+    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorModifier>,
+        node: &'ast Option<PageSelectorType>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_value(
+    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorValue>,
+        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_value(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
-        <V as VisitMut>::visit_mut_opt_combinator(&mut **self, node)
+    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
-        <V as VisitMut>::visit_mut_opt_container_name(&mut **self, node)
+    fn visit_opt_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<SimpleBlock>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
-        <V as VisitMut>::visit_mut_opt_forgiving_selector_list(&mut **self, node)
+    fn visit_opt_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TypeSelector>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
-        <V as VisitMut>::visit_mut_opt_function(&mut **self, node)
+    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
-        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
+    fn visit_opt_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<UrlValue>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
-        <V as VisitMut>::visit_mut_opt_import_conditions(&mut **self, node)
+    fn visit_page_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
-        <V as VisitMut>::visit_mut_opt_import_layer_name(&mut **self, node)
+    fn visit_page_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
-        <V as VisitMut>::visit_mut_opt_important_flag(&mut **self, node)
+    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorPseudo,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_pseudo(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
-        <V as VisitMut>::visit_mut_opt_media_condition_type(&mut **self, node)
+    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelectorPseudo],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
-        <V as VisitMut>::visit_mut_opt_media_query_list(&mut **self, node)
+    fn visit_page_selector_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
-        <V as VisitMut>::visit_mut_opt_media_type(&mut **self, node)
+    fn visit_page_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
-        <V as VisitMut>::visit_mut_opt_namespace(&mut **self, node)
+    fn visit_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Percentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
-        <V as VisitMut>::visit_mut_opt_namespace_prefix(&mut **self, node)
+    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
-        <V as VisitMut>::visit_mut_opt_nesting_selector(&mut **self, node)
+    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
-        <V as VisitMut>::visit_mut_opt_number(&mut **self, node)
+    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PseudoClassSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
-        <V as VisitMut>::visit_mut_opt_page_selector_pseudos(&mut **self, node)
+    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_element_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
-        <V as VisitMut>::visit_mut_opt_page_selector_type(&mut **self, node)
+    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_element_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_class_selector_childrens(
+    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        node: &'ast [PseudoElementSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_element_selector_childrens(
+    fn visit_qualified_rule<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        node: &'ast QualifiedRule,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_qualified_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
-        <V as VisitMut>::visit_mut_opt_simple_block(&mut **self, node)
+    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_qualified_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
-        <V as VisitMut>::visit_mut_opt_type_selector(&mut **self, node)
+    fn visit_query_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QueryInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_query_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
-        <V as VisitMut>::visit_mut_opt_url_modifiers(&mut **self, node)
+    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ratio(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
-        <V as VisitMut>::visit_mut_opt_url_value(&mut **self, node)
+    fn visit_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
-        <V as VisitMut>::visit_mut_page_selector(&mut **self, node)
+    fn visit_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
-        <V as VisitMut>::visit_mut_page_selector_list(&mut **self, node)
+    fn visit_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [RelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
-        <V as VisitMut>::visit_mut_page_selector_pseudo(&mut **self, node)
+    fn visit_resolution<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Resolution,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_resolution(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
-        <V as VisitMut>::visit_mut_page_selector_pseudos(&mut **self, node)
+    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
-        <V as VisitMut>::visit_mut_page_selector_type(&mut **self, node)
+    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_rules(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
-        <V as VisitMut>::visit_mut_page_selectors(&mut **self, node)
+    fn visit_scope_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ScopeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_scope_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
-        <V as VisitMut>::visit_mut_percentage(&mut **self, node)
+    fn visit_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector(&mut **self, node)
+    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SequenceOfCustomIdents,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_sequence_of_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector_children(&mut **self, node)
+    fn visit_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_childrens(
+    fn visit_size_feature<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoClassSelectorChildren>,
+        node: &'ast SizeFeature,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_size_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector(&mut **self, node)
+    fn visit_size_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_children(
+    fn visit_size_feature_name<'ast: 'r, 'r>(
         &mut self,
-        node: &mut PseudoElementSelectorChildren,
+        node: &'ast SizeFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector_children(&mut **self, node)
+        <V as VisitAstPath>::visit_size_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_childrens(
+    fn visit_size_feature_plain<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoElementSelectorChildren>,
+        node: &'ast SizeFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(&mut **self, node)
+        <V as VisitAstPath>::visit_size_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
-        <V as VisitMut>::visit_mut_qualified_rule(&mut **self, node)
+    fn visit_size_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
-        <V as VisitMut>::visit_mut_qualified_rule_prelude(&mut **self, node)
+    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
-        <V as VisitMut>::visit_mut_query_in_parens(&mut **self, node)
+    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
-        <V as VisitMut>::visit_mut_ratio(&mut **self, node)
+    fn visit_size_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
-        <V as VisitMut>::visit_mut_relative_selector(&mut **self, node)
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
-        <V as VisitMut>::visit_mut_relative_selector_list(&mut **self, node)
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
-        <V as VisitMut>::visit_mut_relative_selectors(&mut **self, node)
+    fn visit_style_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StyleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_style_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
-        <V as VisitMut>::visit_mut_resolution(&mut **self, node)
+    fn visit_stylesheet<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Stylesheet,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_stylesheet(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule) {
-        <V as VisitMut>::visit_mut_rule(&mut **self, node)
+    fn visit_subclass_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SubclassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_subclass_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
-        <V as VisitMut>::visit_mut_rules(&mut **self, node)
+    fn visit_subclass_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SubclassSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_subclass_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
-        <V as VisitMut>::visit_mut_scope_range(&mut **self, node)
+    fn visit_supports_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
-        <V as VisitMut>::visit_mut_selector_list(&mut **self, node)
+    fn visit_supports_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
-        <V as VisitMut>::visit_mut_sequence_of_custom_idents(&mut **self, node)
+    fn visit_supports_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
-        <V as VisitMut>::visit_mut_simple_block(&mut **self, node)
+    fn visit_supports_condition_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SupportsConditionType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
-        <V as VisitMut>::visit_mut_size_feature(&mut **self, node)
+    fn visit_supports_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
-        <V as VisitMut>::visit_mut_size_feature_boolean(&mut **self, node)
+    fn visit_supports_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
-        <V as VisitMut>::visit_mut_size_feature_name(&mut **self, node)
+    fn visit_supports_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
-        <V as VisitMut>::visit_mut_size_feature_plain(&mut **self, node)
+    fn visit_supports_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
-        <V as VisitMut>::visit_mut_size_feature_range(&mut **self, node)
+    fn visit_tag_name_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TagNameSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tag_name_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
-        <V as VisitMut>::visit_mut_size_feature_range_comparison(&mut **self, node)
+    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_time(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
-        <V as VisitMut>::visit_mut_size_feature_range_interval(&mut **self, node)
+    fn visit_time_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TimePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_time_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
-        <V as VisitMut>::visit_mut_size_feature_value(&mut **self, node)
+    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
-        <V as VisitMut>::visit_mut_span(&mut **self, node)
+    fn visit_token_and_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TokenAndSpan,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_token_and_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
-        <V as VisitMut>::visit_mut_str(&mut **self, node)
+    fn visit_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TypeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
-        <V as VisitMut>::visit_mut_style_block(&mut **self, node)
+    fn visit_unicode_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnicodeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unicode_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
-        <V as VisitMut>::visit_mut_stylesheet(&mut **self, node)
+    fn visit_universal_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UniversalSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_universal_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
-        <V as VisitMut>::visit_mut_subclass_selector(&mut **self, node)
+    fn visit_unknown_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnknownDimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unknown_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
-        <V as VisitMut>::visit_mut_subclass_selectors(&mut **self, node)
+    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_url(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
-        <V as VisitMut>::visit_mut_supports_and(&mut **self, node)
+    fn visit_url_key_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlKeyValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_key_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
-        <V as VisitMut>::visit_mut_supports_condition(&mut **self, node)
+    fn visit_url_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
-        <V as VisitMut>::visit_mut_supports_condition_type(&mut **self, node)
+    fn visit_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [UrlModifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
-        <V as VisitMut>::visit_mut_supports_condition_types(&mut **self, node)
+    fn visit_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
-        <V as VisitMut>::visit_mut_supports_feature(&mut **self, node)
+    fn visit_url_value_raw<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValueRaw,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_value_raw(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
-        <V as VisitMut>::visit_mut_supports_in_parens(&mut **self, node)
+    fn visit_wq_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WqName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_wq_name(&mut **self, node, __ast_path)
     }
-
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<A, B> VisitAstPath for ::swc_visit::Either<A, B>
+where
+    A: VisitAstPath,
+    B: VisitAstPath,
+{
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
-        <V as VisitMut>::visit_mut_supports_not(&mut **self, node)
+    fn visit_absolute_color_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AbsoluteColorBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_absolute_color_base(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_absolute_color_base(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
-        <V as VisitMut>::visit_mut_supports_or(&mut **self, node)
+    fn visit_alpha_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AlphaValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_alpha_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_alpha_value(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
-        <V as VisitMut>::visit_mut_tag_name_selector(&mut **self, node)
+    fn visit_an_plus_b<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusB,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_an_plus_b(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_an_plus_b(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time) {
-        <V as VisitMut>::visit_mut_time(&mut **self, node)
+    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusBNotation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_an_plus_b_notation(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_an_plus_b_notation(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
-        <V as VisitMut>::visit_mut_time_percentage(&mut **self, node)
+    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_angle(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_angle(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token) {
-        <V as VisitMut>::visit_mut_token(&mut **self, node)
+    fn visit_angle_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnglePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_angle_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_angle_percentage(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
-        <V as VisitMut>::visit_mut_token_and_span(&mut **self, node)
+    fn visit_any_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnyNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_any_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_any_namespace(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
-        <V as VisitMut>::visit_mut_type_selector(&mut **self, node)
+    fn visit_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_at_rule(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_at_rule(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
-        <V as VisitMut>::visit_mut_unicode_range(&mut **self, node)
+    fn visit_at_rule_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_at_rule_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_at_rule_name(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
-        <V as VisitMut>::visit_mut_universal_selector(&mut **self, node)
+    fn visit_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_at_rule_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_at_rule_prelude(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
-        <V as VisitMut>::visit_mut_unknown_dimension(&mut **self, node)
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_atom(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_atom(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url) {
-        <V as VisitMut>::visit_mut_url(&mut **self, node)
+    fn visit_attribute_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_attribute_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_attribute_selector(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
-        <V as VisitMut>::visit_mut_url_key_value(&mut **self, node)
+    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcher,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_attribute_selector_matcher(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_attribute_selector_matcher(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
-        <V as VisitMut>::visit_mut_url_modifier(&mut **self, node)
+    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcherValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_attribute_selector_matcher_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_attribute_selector_matcher_value(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
-        <V as VisitMut>::visit_mut_url_modifiers(&mut **self, node)
+    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_attribute_selector_modifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_attribute_selector_modifier(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
-        <V as VisitMut>::visit_mut_url_value(&mut **self, node)
+    fn visit_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_attribute_selector_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_attribute_selector_value(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
-        <V as VisitMut>::visit_mut_url_value_raw(&mut **self, node)
+    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_bin_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_bin_op(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
-        <V as VisitMut>::visit_mut_wq_name(&mut **self, node)
+    fn visit_calc_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_calc_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_calc_operator(visitor, node, __ast_path)
+            }
+        }
     }
-}
-impl<A, B> VisitMut for ::swc_visit::Either<A, B>
-where
-    A: VisitMut,
-    B: VisitMut,
-{
+
     #[inline]
-    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
+    fn visit_calc_operator_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperatorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_absolute_color_base(visitor, node)
+                VisitAstPath::visit_calc_operator_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_absolute_color_base(visitor, node)
+                VisitAstPath::visit_calc_operator_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
+    fn visit_calc_product<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProduct,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_alpha_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_alpha_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_calc_product(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_calc_product(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
+    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProductOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_an_plus_b(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_an_plus_b(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_calc_product_or_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_calc_product_or_operator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
+    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcProductOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_an_plus_b_notation(visitor, node)
+                VisitAstPath::visit_calc_product_or_operators(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_an_plus_b_notation(visitor, node)
+                VisitAstPath::visit_calc_product_or_operators(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle) {
+    fn visit_calc_sum<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcSum,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_angle(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_angle(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_calc_sum(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_calc_sum(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
+    fn visit_calc_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_angle_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_calc_value(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_angle_percentage(visitor, node)
+                VisitAstPath::visit_calc_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
+    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValueOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_any_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_any_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_calc_value_or_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_calc_value_or_operator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
+    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcValueOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_at_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_at_rule(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_calc_value_or_operators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_calc_value_or_operators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
+    fn visit_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_at_rule_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_at_rule_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
+    fn visit_cmyk_component<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CmykComponent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_at_rule_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_at_rule_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_cmyk_component(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_cmyk_component(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_color(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_color(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
+    fn visit_color_profile_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ColorProfileName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_attribute_selector(visitor, node)
+                VisitAstPath::visit_color_profile_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_attribute_selector(visitor, node)
+                VisitAstPath::visit_color_profile_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
+    fn visit_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Combinator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_attribute_selector_matcher(visitor, node)
+                VisitAstPath::visit_combinator(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_attribute_selector_matcher(visitor, node)
+                VisitAstPath::visit_combinator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher_value(
+    fn visit_combinator_value<'ast: 'r, 'r>(
         &mut self,
-        node: &mut AttributeSelectorMatcherValue,
+        node: &'ast CombinatorValue,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_attribute_selector_matcher_value(visitor, node)
+                VisitAstPath::visit_combinator_value(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_attribute_selector_matcher_value(visitor, node)
+                VisitAstPath::visit_combinator_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
+    fn visit_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_attribute_selector_modifier(visitor, node)
+                VisitAstPath::visit_complex_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_attribute_selector_modifier(visitor, node)
+                VisitAstPath::visit_complex_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
+    fn visit_complex_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_attribute_selector_value(visitor, node)
+                VisitAstPath::visit_complex_selector_children(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_attribute_selector_value(visitor, node)
+                VisitAstPath::visit_complex_selector_children(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
+    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_bin_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_bin_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_complex_selector_childrens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_complex_selector_childrens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
+    fn visit_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_operator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_operator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_complex_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_complex_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
+    fn visit_component_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComponentValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_calc_operator_type(visitor, node)
+                VisitAstPath::visit_component_value(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_calc_operator_type(visitor, node)
+                VisitAstPath::visit_component_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
+    fn visit_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComponentValue],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_product(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_product(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_component_values(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_component_values(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
+    fn visit_compound_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_calc_product_or_operator(visitor, node)
+                VisitAstPath::visit_compound_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_calc_product_or_operator(visitor, node)
+                VisitAstPath::visit_compound_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
+    fn visit_compound_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_calc_product_or_operators(visitor, node)
+                VisitAstPath::visit_compound_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_calc_product_or_operators(visitor, node)
+                VisitAstPath::visit_compound_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
+    fn visit_compound_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CompoundSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_sum(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_sum(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_compound_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_compound_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
+    fn visit_container_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_container_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_container_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
+    fn visit_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_calc_value_or_operator(visitor, node)
+                VisitAstPath::visit_container_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_calc_value_or_operator(visitor, node)
+                VisitAstPath::visit_container_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
+    fn visit_container_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_calc_value_or_operators(visitor, node)
+                VisitAstPath::visit_container_query(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_calc_value_or_operators(visitor, node)
+                VisitAstPath::visit_container_query(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
+    fn visit_container_query_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_container_query_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_container_query_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
+    fn visit_container_query_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_cmyk_component(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_cmyk_component(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_container_query_not(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_container_query_not(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color) {
+    fn visit_container_query_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_color(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_color(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_container_query_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_container_query_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
+    fn visit_container_query_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_color_profile_name(visitor, node)
+                VisitAstPath::visit_container_query_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_color_profile_name(visitor, node)
+                VisitAstPath::visit_container_query_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
+    fn visit_container_query_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ContainerQueryType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_combinator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_combinator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_container_query_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_container_query_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
+    fn visit_custom_highlight_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomHighlightName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_combinator_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_custom_highlight_name(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_combinator_value(visitor, node)
+                VisitAstPath::visit_custom_highlight_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
+    fn visit_custom_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_complex_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_custom_ident(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_complex_selector(visitor, node)
+                VisitAstPath::visit_custom_ident(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
+    fn visit_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CustomIdent],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_complex_selector_children(visitor, node)
+                VisitAstPath::visit_custom_idents(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_complex_selector_children(visitor, node)
+                VisitAstPath::visit_custom_idents(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
+    fn visit_custom_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_complex_selector_childrens(visitor, node)
+                VisitAstPath::visit_custom_media_query(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_complex_selector_childrens(visitor, node)
+                VisitAstPath::visit_custom_media_query(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
+    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQueryMediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_complex_selectors(visitor, node)
+                VisitAstPath::visit_custom_media_query_media_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_complex_selectors(visitor, node)
+                VisitAstPath::visit_custom_media_query_media_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
+    fn visit_custom_property_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomPropertyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_component_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_component_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_custom_property_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_custom_property_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
+    fn visit_dashed_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DashedIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_component_values(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_dashed_ident(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_component_values(visitor, node)
+                VisitAstPath::visit_dashed_ident(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
+    fn visit_declaration<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Declaration,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_compound_selector(visitor, node)
+                VisitAstPath::visit_declaration(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_compound_selector(visitor, node)
+                VisitAstPath::visit_declaration(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
+    fn visit_declaration_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_compound_selector_list(visitor, node)
+                VisitAstPath::visit_declaration_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_compound_selector_list(visitor, node)
+                VisitAstPath::visit_declaration_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
+    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationOrAtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_compound_selectors(visitor, node)
+                VisitAstPath::visit_declaration_or_at_rule(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_compound_selectors(visitor, node)
+                VisitAstPath::visit_declaration_or_at_rule(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
+    fn visit_delimiter<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Delimiter,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_container_condition(visitor, node)
+                VisitAstPath::visit_delimiter(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_container_condition(visitor, node)
+                VisitAstPath::visit_delimiter(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
+    fn visit_delimiter_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DelimiterValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_container_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_container_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_delimiter_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_delimiter_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
+    fn visit_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Dimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_container_query(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_container_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_dimension(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_dimension(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
+    fn visit_dimension_token<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DimensionToken,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_container_query_and(visitor, node)
+                VisitAstPath::visit_dimension_token(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_container_query_and(visitor, node)
+                VisitAstPath::visit_dimension_token(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
+    fn visit_document_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_container_query_not(visitor, node)
+                VisitAstPath::visit_document_prelude(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_container_query_not(visitor, node)
+                VisitAstPath::visit_document_prelude(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
+    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_container_query_or(visitor, node)
+                VisitAstPath::visit_document_prelude_matching_function(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_container_query_or(visitor, node)
+                VisitAstPath::visit_document_prelude_matching_function(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
+    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [DocumentPreludeMatchingFunction],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_container_query_type(visitor, node)
+                VisitAstPath::visit_document_prelude_matching_functions(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_container_query_type(visitor, node)
+                VisitAstPath::visit_document_prelude_matching_functions(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
+    fn visit_extension_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExtensionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_container_query_types(visitor, node)
+                VisitAstPath::visit_extension_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_container_query_types(visitor, node)
+                VisitAstPath::visit_extension_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
+    fn visit_family_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FamilyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_custom_highlight_name(visitor, node)
+                VisitAstPath::visit_family_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_custom_highlight_name(visitor, node)
+                VisitAstPath::visit_family_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
+    fn visit_family_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [FamilyName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_custom_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_custom_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_family_names(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_family_names(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
+    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_custom_idents(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_custom_idents(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_flex(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_flex(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
+    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FontFeatureValuesPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_custom_media_query(visitor, node)
+                VisitAstPath::visit_font_feature_values_prelude(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_custom_media_query(visitor, node)
+                VisitAstPath::visit_font_feature_values_prelude(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
+    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_custom_media_query_media_type(visitor, node)
+                VisitAstPath::visit_forgiving_complex_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_custom_media_query_media_type(visitor, node)
+                VisitAstPath::visit_forgiving_complex_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
+    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_custom_property_name(visitor, node)
+                VisitAstPath::visit_forgiving_complex_selectors(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_custom_property_name(visitor, node)
+                VisitAstPath::visit_forgiving_complex_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_dashed_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_dashed_ident(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
+    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_declaration(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_declaration(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_forgiving_relative_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_forgiving_relative_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
+    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_declaration_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_forgiving_relative_selector_list(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_declaration_name(visitor, node)
+                VisitAstPath::visit_forgiving_relative_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
+    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingRelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_declaration_or_at_rule(visitor, node)
+                VisitAstPath::visit_forgiving_relative_selectors(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_declaration_or_at_rule(visitor, node)
+                VisitAstPath::visit_forgiving_relative_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
+    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_delimiter(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_delimiter(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_forgiving_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_forgiving_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
+    fn visit_frequency<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Frequency,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_delimiter_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_delimiter_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_frequency(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_frequency(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
+    fn visit_frequency_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FrequencyPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_dimension(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_dimension(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_frequency_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_frequency_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_dimension_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_dimension_token(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
+    fn visit_function_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FunctionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_document_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_function_name(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_document_prelude(visitor, node)
+                VisitAstPath::visit_function_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_function(
+    fn visit_general_enclosed<'ast: 'r, 'r>(
         &mut self,
-        node: &mut DocumentPreludeMatchingFunction,
+        node: &'ast GeneralEnclosed,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_document_prelude_matching_function(visitor, node)
+                VisitAstPath::visit_general_enclosed(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_document_prelude_matching_function(visitor, node)
+                VisitAstPath::visit_general_enclosed(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_functions(
+    fn visit_hex_color<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        node: &'ast HexColor,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_document_prelude_matching_functions(visitor, node)
+                VisitAstPath::visit_hex_color(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_document_prelude_matching_functions(visitor, node)
+                VisitAstPath::visit_hex_color(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_extension_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_extension_name(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_family_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_family_name(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_family_names(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_family_names(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex) {
+    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_flex(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_flex(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_hue(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_hue(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
+    fn visit_id_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_font_feature_values_prelude(visitor, node)
+                VisitAstPath::visit_id_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_font_feature_values_prelude(visitor, node)
+                VisitAstPath::visit_id_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_forgiving_complex_selector(visitor, node)
+                VisitAstPath::visit_ident(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_forgiving_complex_selector(visitor, node)
+                VisitAstPath::visit_ident(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
+    fn visit_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Ident],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_forgiving_complex_selectors(visitor, node)
+                VisitAstPath::visit_idents(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_forgiving_complex_selectors(visitor, node)
+                VisitAstPath::visit_idents(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
+    fn visit_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportConditions,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_forgiving_relative_selector(visitor, node)
+                VisitAstPath::visit_import_conditions(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_forgiving_relative_selector(visitor, node)
+                VisitAstPath::visit_import_conditions(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector_list(
+    fn visit_import_href<'ast: 'r, 'r>(
         &mut self,
-        node: &mut ForgivingRelativeSelectorList,
+        node: &'ast ImportHref,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_forgiving_relative_selector_list(visitor, node)
+                VisitAstPath::visit_import_href(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_forgiving_relative_selector_list(visitor, node)
+                VisitAstPath::visit_import_href(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selectors(
+    fn visit_import_layer_name<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<ForgivingRelativeSelector>,
+        node: &'ast ImportLayerName,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_forgiving_relative_selectors(visitor, node)
+                VisitAstPath::visit_import_layer_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_forgiving_relative_selectors(visitor, node)
+                VisitAstPath::visit_import_layer_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
+    fn visit_import_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_forgiving_selector_list(visitor, node)
+                VisitAstPath::visit_import_prelude(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_forgiving_selector_list(visitor, node)
+                VisitAstPath::visit_import_prelude(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
+    fn visit_important_flag<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportantFlag,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_frequency(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_frequency(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_important_flag(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_important_flag(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
+    fn visit_integer<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Integer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_frequency_percentage(visitor, node)
+                VisitAstPath::visit_integer(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_frequency_percentage(visitor, node)
+                VisitAstPath::visit_integer(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
+    fn visit_keyframe_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_function(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_keyframe_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_keyframe_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
+    fn visit_keyframe_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_function_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_function_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_keyframe_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_keyframe_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
+    fn visit_keyframe_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [KeyframeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_general_enclosed(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_keyframe_selectors(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_general_enclosed(visitor, node)
+                VisitAstPath::visit_keyframe_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
+    fn visit_keyframes_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_hex_color(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_hex_color(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_keyframes_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_keyframes_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue) {
+    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_hue(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_hue(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_keyframes_pseudo_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_keyframes_pseudo_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
+    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoPrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_id_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_id_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_keyframes_pseudo_prefix(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_keyframes_pseudo_prefix(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
+    fn visit_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_layer_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_layer_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
+    fn visit_layer_name_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerNameList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_idents(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_idents(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_layer_name_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_layer_name_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
+    fn visit_layer_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [LayerName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_import_conditions(visitor, node)
+                VisitAstPath::visit_layer_names(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_conditions(visitor, node)
+                VisitAstPath::visit_layer_names(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
+    fn visit_layer_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_href(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_href(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_layer_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_layer_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
+    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_import_layer_name(visitor, node)
+                VisitAstPath::visit_length(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_layer_name(visitor, node)
+                VisitAstPath::visit_length(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
+    fn visit_length_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LengthPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_length_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_length_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
+    fn visit_list_of_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ListOfComponentValues,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_important_flag(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_important_flag(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_list_of_component_values(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_list_of_component_values(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer) {
+    fn visit_media_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_integer(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_integer(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
+    fn visit_media_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_keyframe_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_keyframe_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
+    fn visit_media_condition_all_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionAllType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_keyframe_selector(visitor, node)
+                VisitAstPath::visit_media_condition_all_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_keyframe_selector(visitor, node)
+                VisitAstPath::visit_media_condition_all_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
+    fn visit_media_condition_all_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionAllType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_keyframe_selectors(visitor, node)
+                VisitAstPath::visit_media_condition_all_types(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_keyframe_selectors(visitor, node)
+                VisitAstPath::visit_media_condition_all_types(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
+    fn visit_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_keyframes_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_keyframes_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_condition_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_condition_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
+    fn visit_media_condition_without_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_keyframes_pseudo_function(visitor, node)
+                VisitAstPath::visit_media_condition_without_or(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_keyframes_pseudo_function(visitor, node)
+                VisitAstPath::visit_media_condition_without_or(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
+    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOrType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_keyframes_pseudo_prefix(visitor, node)
+                VisitAstPath::visit_media_condition_without_or_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_keyframes_pseudo_prefix(visitor, node)
+                VisitAstPath::visit_media_condition_without_or_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
+    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionWithoutOrType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_condition_without_or_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_condition_without_or_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
+    fn visit_media_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_name_list(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_name_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_feature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_feature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
+    fn visit_media_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_names(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_names(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_feature_boolean(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_feature_boolean(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
+    fn visit_media_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_feature_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_feature_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length) {
+    fn visit_media_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_length(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_length(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_feature_plain(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_feature_plain(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
+    fn visit_media_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_length_percentage(visitor, node)
+                VisitAstPath::visit_media_feature_range(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_length_percentage(visitor, node)
+                VisitAstPath::visit_media_feature_range(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
+    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_list_of_component_values(visitor, node)
+                VisitAstPath::visit_media_feature_range_comparison(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_list_of_component_values(visitor, node)
+                VisitAstPath::visit_media_feature_range_comparison(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
+    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_and(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_feature_range_interval(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_feature_range_interval(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
+    fn visit_media_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_condition(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_condition(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_media_feature_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_media_feature_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
+    fn visit_media_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_condition_all_type(visitor, node)
+                VisitAstPath::visit_media_in_parens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_condition_all_type(visitor, node)
+                VisitAstPath::visit_media_in_parens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
+    fn visit_media_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_condition_all_types(visitor, node)
+                VisitAstPath::visit_media_not(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_condition_all_types(visitor, node)
+                VisitAstPath::visit_media_not(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
+    fn visit_media_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_condition_type(visitor, node)
+                VisitAstPath::visit_media_or(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_condition_type(visitor, node)
+                VisitAstPath::visit_media_or(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
+    fn visit_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_condition_without_or(visitor, node)
+                VisitAstPath::visit_media_query(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_condition_without_or(visitor, node)
+                VisitAstPath::visit_media_query(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_type(
+    fn visit_media_query_list<'ast: 'r, 'r>(
         &mut self,
-        node: &mut MediaConditionWithoutOrType,
+        node: &'ast MediaQueryList,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_condition_without_or_type(visitor, node)
+                VisitAstPath::visit_media_query_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_condition_without_or_type(visitor, node)
+                VisitAstPath::visit_media_query_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_types(
+    fn visit_media_querys<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<MediaConditionWithoutOrType>,
+        node: &'ast [MediaQuery],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_condition_without_or_types(visitor, node)
+                VisitAstPath::visit_media_querys(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_condition_without_or_types(visitor, node)
+                VisitAstPath::visit_media_querys(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_feature(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
+    fn visit_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_feature_boolean(visitor, node)
+                VisitAstPath::visit_media_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_feature_boolean(visitor, node)
+                VisitAstPath::visit_media_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
+    fn visit_named_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_feature_name(visitor, node)
+                VisitAstPath::visit_named_namespace(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_feature_name(visitor, node)
+                VisitAstPath::visit_named_namespace(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
+    fn visit_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Namespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_feature_plain(visitor, node)
+                VisitAstPath::visit_namespace(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_feature_plain(visitor, node)
+                VisitAstPath::visit_namespace(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
+    fn visit_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_feature_range(visitor, node)
+                VisitAstPath::visit_namespace_prefix(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_feature_range(visitor, node)
+                VisitAstPath::visit_namespace_prefix(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
+    fn visit_namespace_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_feature_range_comparison(visitor, node)
+                VisitAstPath::visit_namespace_prelude(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_feature_range_comparison(visitor, node)
+                VisitAstPath::visit_namespace_prelude(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
+    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePreludeUri,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_feature_range_interval(visitor, node)
+                VisitAstPath::visit_namespace_prelude_uri(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_feature_range_interval(visitor, node)
+                VisitAstPath::visit_namespace_prelude_uri(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
+    fn visit_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NestingSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_media_feature_value(visitor, node)
+                VisitAstPath::visit_nesting_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_feature_value(visitor, node)
+                VisitAstPath::visit_nesting_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_in_parens(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_not(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_not(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_or(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_or(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_query(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_query(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_query_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_number(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_media_query_list(visitor, node)
+                VisitAstPath::visit_number(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_querys(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_querys(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
+    fn visit_number_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NumberType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_number_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_number_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
+    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_named_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_named_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_at_rule_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_at_rule_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
+    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_namespace_prefix(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_attribute_selector_matcher(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_namespace_prefix(visitor, node)
+                VisitAstPath::visit_opt_attribute_selector_matcher(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
+    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_namespace_prelude(visitor, node)
+                VisitAstPath::visit_opt_attribute_selector_modifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_namespace_prelude(visitor, node)
+                VisitAstPath::visit_opt_attribute_selector_modifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
+    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<AttributeSelectorValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_namespace_prelude_uri(visitor, node)
+                VisitAstPath::visit_opt_attribute_selector_value(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_namespace_prelude_uri(visitor, node)
+                VisitAstPath::visit_opt_attribute_selector_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
+    fn visit_opt_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Combinator>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_nesting_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_combinator(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_nesting_selector(visitor, node)
+                VisitAstPath::visit_opt_combinator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
+    fn visit_opt_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ContainerName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_number(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_container_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_container_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
+    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ForgivingSelectorList>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_number_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_number_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_forgiving_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_forgiving_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
+    fn visit_opt_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Function>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_at_rule_prelude(visitor, node)
+                VisitAstPath::visit_opt_function(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_at_rule_prelude(visitor, node)
+                VisitAstPath::visit_opt_function(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_matcher(
+    fn visit_opt_import_conditions<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorMatcher>,
+        node: &'ast Option<Box<ImportConditions>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_attribute_selector_matcher(visitor, node)
+                VisitAstPath::visit_opt_import_conditions(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_attribute_selector_matcher(visitor, node)
+                VisitAstPath::visit_opt_import_conditions(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_modifier(
+    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorModifier>,
+        node: &'ast Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_attribute_selector_modifier(visitor, node)
+                VisitAstPath::visit_opt_import_layer_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_attribute_selector_modifier(visitor, node)
+                VisitAstPath::visit_opt_import_layer_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_value(
+    fn visit_opt_important_flag<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorValue>,
+        node: &'ast Option<ImportantFlag>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_attribute_selector_value(visitor, node)
+                VisitAstPath::visit_opt_important_flag(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_attribute_selector_value(visitor, node)
+                VisitAstPath::visit_opt_important_flag(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
+    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_combinator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_combinator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_media_condition_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_media_condition_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
+    fn visit_opt_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_container_name(visitor, node)
+                VisitAstPath::visit_opt_media_query_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_container_name(visitor, node)
+                VisitAstPath::visit_opt_media_query_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
+    fn visit_opt_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<MediaType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_forgiving_selector_list(visitor, node)
+                VisitAstPath::visit_opt_media_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_forgiving_selector_list(visitor, node)
+                VisitAstPath::visit_opt_media_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
+    fn visit_opt_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Namespace>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_function(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_namespace(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NamespacePrefix>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_namespace_prefix(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_namespace_prefix(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
+    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NestingSelector>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_import_conditions(visitor, node)
+                VisitAstPath::visit_opt_nesting_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_import_conditions(visitor, node)
+                VisitAstPath::visit_opt_nesting_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
+    fn visit_opt_number<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Number>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_import_layer_name(visitor, node)
+                VisitAstPath::visit_opt_number(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_import_layer_name(visitor, node)
+                VisitAstPath::visit_opt_number(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
+    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_important_flag(visitor, node)
+                VisitAstPath::visit_opt_page_selector_pseudos(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_important_flag(visitor, node)
+                VisitAstPath::visit_opt_page_selector_pseudos(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
+    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<PageSelectorType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_media_condition_type(visitor, node)
+                VisitAstPath::visit_opt_page_selector_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_media_condition_type(visitor, node)
+                VisitAstPath::visit_opt_page_selector_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
+    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_media_query_list(visitor, node)
+                VisitAstPath::visit_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_media_query_list(visitor, node)
+                VisitAstPath::visit_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
+    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_media_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_media_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
+    fn visit_opt_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<SimpleBlock>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_simple_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_simple_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
+    fn visit_opt_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TypeSelector>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_namespace_prefix(visitor, node)
+                VisitAstPath::visit_opt_type_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_namespace_prefix(visitor, node)
+                VisitAstPath::visit_opt_type_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
+    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_nesting_selector(visitor, node)
+                VisitAstPath::visit_opt_url_modifiers(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_nesting_selector(visitor, node)
+                VisitAstPath::visit_opt_url_modifiers(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
+    fn visit_opt_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<UrlValue>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_number(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_url_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_url_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
+    fn visit_page_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_page_selector_pseudos(visitor, node)
+                VisitAstPath::visit_page_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_page_selector_pseudos(visitor, node)
+                VisitAstPath::visit_page_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
+    fn visit_page_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_page_selector_type(visitor, node)
+                VisitAstPath::visit_page_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_page_selector_type(visitor, node)
+                VisitAstPath::visit_page_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_class_selector_childrens(
+    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        node: &'ast PageSelectorPseudo,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_pseudo_class_selector_childrens(visitor, node)
+                VisitAstPath::visit_page_selector_pseudo(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_pseudo_class_selector_childrens(visitor, node)
+                VisitAstPath::visit_page_selector_pseudo(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_element_selector_childrens(
+    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        node: &'ast [PageSelectorPseudo],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_pseudo_element_selector_childrens(visitor, node)
+                VisitAstPath::visit_page_selector_pseudos(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_pseudo_element_selector_childrens(visitor, node)
+                VisitAstPath::visit_page_selector_pseudos(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
+    fn visit_page_selector_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_simple_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_page_selector_type(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_simple_block(visitor, node)
+                VisitAstPath::visit_page_selector_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
+    fn visit_page_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_type_selector(visitor, node)
+                VisitAstPath::visit_page_selectors(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_type_selector(visitor, node)
+                VisitAstPath::visit_page_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
+    fn visit_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Percentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_url_modifiers(visitor, node)
+                VisitAstPath::visit_percentage(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_url_modifiers(visitor, node)
+                VisitAstPath::visit_percentage(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_url_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_url_value(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_page_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_page_selector(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
+    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_page_selector_list(visitor, node)
+                VisitAstPath::visit_pseudo_class_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_page_selector_list(visitor, node)
+                VisitAstPath::visit_pseudo_class_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
+    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_page_selector_pseudo(visitor, node)
+                VisitAstPath::visit_pseudo_class_selector_children(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_page_selector_pseudo(visitor, node)
+                VisitAstPath::visit_pseudo_class_selector_children(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
+    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PseudoClassSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_page_selector_pseudos(visitor, node)
+                VisitAstPath::visit_pseudo_class_selector_childrens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_page_selector_pseudos(visitor, node)
+                VisitAstPath::visit_pseudo_class_selector_childrens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
+    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_page_selector_type(visitor, node)
+                VisitAstPath::visit_pseudo_element_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_page_selector_type(visitor, node)
+                VisitAstPath::visit_pseudo_element_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
+    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_page_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_page_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_pseudo_element_selector_children(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_pseudo_element_selector_children(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
+    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PseudoElementSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_pseudo_element_selector_childrens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_pseudo_element_selector_childrens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
+    fn visit_qualified_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_pseudo_class_selector(visitor, node)
+                VisitAstPath::visit_qualified_rule(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_pseudo_class_selector(visitor, node)
+                VisitAstPath::visit_qualified_rule(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
+    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_pseudo_class_selector_children(visitor, node)
+                VisitAstPath::visit_qualified_rule_prelude(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_pseudo_class_selector_children(visitor, node)
+                VisitAstPath::visit_qualified_rule_prelude(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_childrens(
+    fn visit_query_in_parens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoClassSelectorChildren>,
+        node: &'ast QueryInParens,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_pseudo_class_selector_childrens(visitor, node)
+                VisitAstPath::visit_query_in_parens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_pseudo_class_selector_childrens(visitor, node)
+                VisitAstPath::visit_query_in_parens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
+    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_pseudo_element_selector(visitor, node)
+                VisitAstPath::visit_ratio(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_pseudo_element_selector(visitor, node)
+                VisitAstPath::visit_ratio(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_children(
+    fn visit_relative_selector<'ast: 'r, 'r>(
         &mut self,
-        node: &mut PseudoElementSelectorChildren,
+        node: &'ast RelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_pseudo_element_selector_children(visitor, node)
+                VisitAstPath::visit_relative_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_pseudo_element_selector_children(visitor, node)
+                VisitAstPath::visit_relative_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_childrens(
+    fn visit_relative_selector_list<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoElementSelectorChildren>,
+        node: &'ast RelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_pseudo_element_selector_childrens(visitor, node)
+                VisitAstPath::visit_relative_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_pseudo_element_selector_childrens(visitor, node)
+                VisitAstPath::visit_relative_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_qualified_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_qualified_rule(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
+    fn visit_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [RelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_qualified_rule_prelude(visitor, node)
+                VisitAstPath::visit_relative_selectors(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_qualified_rule_prelude(visitor, node)
+                VisitAstPath::visit_relative_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
+    fn visit_resolution<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Resolution,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_query_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_query_in_parens(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_resolution(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_resolution(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
+    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ratio(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ratio(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_rule(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_rule(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
+    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_relative_selector(visitor, node)
+                VisitAstPath::visit_rules(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_relative_selector(visitor, node)
+                VisitAstPath::visit_rules(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
+    fn visit_scope_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ScopeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_relative_selector_list(visitor, node)
+                VisitAstPath::visit_scope_range(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_relative_selector_list(visitor, node)
+                VisitAstPath::visit_scope_range(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
+    fn visit_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_relative_selectors(visitor, node)
+                VisitAstPath::visit_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_relative_selectors(visitor, node)
+                VisitAstPath::visit_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_resolution(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_resolution(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_rule(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_rules(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_rules(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_scope_range(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_scope_range(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
+    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SequenceOfCustomIdents,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_sequence_of_custom_idents(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_sequence_of_custom_idents(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
+    fn visit_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_sequence_of_custom_idents(visitor, node)
+                VisitAstPath::visit_simple_block(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_sequence_of_custom_idents(visitor, node)
+                VisitAstPath::visit_simple_block(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
+    fn visit_size_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_simple_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_simple_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_size_feature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_size_feature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
+    fn visit_size_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_size_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_size_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_size_feature_boolean(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_size_feature_boolean(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
+    fn visit_size_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_size_feature_boolean(visitor, node)
+                VisitAstPath::visit_size_feature_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_size_feature_boolean(visitor, node)
+                VisitAstPath::visit_size_feature_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
+    fn visit_size_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_size_feature_name(visitor, node)
+                VisitAstPath::visit_size_feature_plain(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_size_feature_name(visitor, node)
+                VisitAstPath::visit_size_feature_plain(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
+    fn visit_size_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_size_feature_plain(visitor, node)
+                VisitAstPath::visit_size_feature_range(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_size_feature_plain(visitor, node)
+                VisitAstPath::visit_size_feature_range(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
+    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_size_feature_range(visitor, node)
+                VisitAstPath::visit_size_feature_range_comparison(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_size_feature_range(visitor, node)
+                VisitAstPath::visit_size_feature_range_comparison(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
+    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_size_feature_range_comparison(visitor, node)
+                VisitAstPath::visit_size_feature_range_interval(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_size_feature_range_comparison(visitor, node)
+                VisitAstPath::visit_size_feature_range_interval(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
+    fn visit_size_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_size_feature_range_interval(visitor, node)
+                VisitAstPath::visit_size_feature_value(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_size_feature_range_interval(visitor, node)
+                VisitAstPath::visit_size_feature_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_size_feature_value(visitor, node)
-            }
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_span(visitor, node, __ast_path),
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_size_feature_value(visitor, node)
+                VisitAstPath::visit_span(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_span(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
+    fn visit_style_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StyleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_str(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_str(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_style_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_style_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
+    fn visit_stylesheet<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Stylesheet,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_style_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_style_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_stylesheet(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_stylesheet(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
+    fn visit_subclass_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SubclassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_stylesheet(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_stylesheet(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_subclass_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_subclass_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
+    fn visit_subclass_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SubclassSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_subclass_selector(visitor, node)
+                VisitAstPath::visit_subclass_selectors(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_subclass_selector(visitor, node)
+                VisitAstPath::visit_subclass_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
+    fn visit_supports_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_subclass_selectors(visitor, node)
+                VisitAstPath::visit_supports_and(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_subclass_selectors(visitor, node)
+                VisitAstPath::visit_supports_and(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
+    fn visit_supports_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_and(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_supports_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_supports_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_supports_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
+    fn visit_supports_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_supports_condition(visitor, node)
+                VisitAstPath::visit_supports_condition_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_supports_condition(visitor, node)
+                VisitAstPath::visit_supports_condition_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
+    fn visit_supports_condition_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SupportsConditionType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_supports_condition_type(visitor, node)
+                VisitAstPath::visit_supports_condition_types(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_supports_condition_type(visitor, node)
+                VisitAstPath::visit_supports_condition_types(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
+    fn visit_supports_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_supports_condition_types(visitor, node)
+                VisitAstPath::visit_supports_feature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_supports_condition_types(visitor, node)
+                VisitAstPath::visit_supports_feature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
+    fn visit_supports_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_supports_in_parens(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_supports_feature(visitor, node)
+                VisitAstPath::visit_supports_in_parens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
+    fn visit_supports_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_supports_in_parens(visitor, node)
+                VisitAstPath::visit_supports_not(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_supports_in_parens(visitor, node)
+                VisitAstPath::visit_supports_not(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_not(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_supports_not(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
+    fn visit_supports_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_or(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_supports_or(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_supports_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_supports_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
+    fn visit_tag_name_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TagNameSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_tag_name_selector(visitor, node)
+                VisitAstPath::visit_tag_name_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_tag_name_selector(visitor, node)
+                VisitAstPath::visit_tag_name_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time) {
+    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_time(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_time(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_time(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_time(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
+    fn visit_time_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TimePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_time_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_time_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_time_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_time_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token) {
+    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_token(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_token(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_token(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
+    fn visit_token_and_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TokenAndSpan,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_token_and_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_token_and_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_token_and_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_token_and_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
+    fn visit_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TypeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_type_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_type_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_type_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_type_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
+    fn visit_unicode_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnicodeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_unicode_range(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_unicode_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_unicode_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_unicode_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
+    fn visit_universal_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UniversalSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_universal_selector(visitor, node)
+                VisitAstPath::visit_universal_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_universal_selector(visitor, node)
+                VisitAstPath::visit_universal_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
+    fn visit_unknown_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnknownDimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_unknown_dimension(visitor, node)
+                VisitAstPath::visit_unknown_dimension(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_unknown_dimension(visitor, node)
+                VisitAstPath::visit_unknown_dimension(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url) {
+    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_url(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_url(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
+    fn visit_url_key_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlKeyValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_key_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_key_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_url_key_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_url_key_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
+    fn visit_url_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_modifier(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_modifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_url_modifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_url_modifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
+    fn visit_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [UrlModifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_modifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_modifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_url_modifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_url_modifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
+    fn visit_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_url_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_url_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
+    fn visit_url_value_raw<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValueRaw,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_value_raw(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_value_raw(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_url_value_raw(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_url_value_raw(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
+    fn visit_wq_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WqName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_wq_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_wq_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_wq_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_wq_name(visitor, node, __ast_path)
+            }
         }
     }
 }
-impl<V> VisitMut for ::swc_visit::Optional<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitAstPath for ::swc_visit::Optional<V>
 where
-    V: VisitMut,
+    V: VisitAstPath,
 {
     #[inline]
-    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
+    fn visit_absolute_color_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AbsoluteColorBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_absolute_color_base(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_absolute_color_base(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
+    fn visit_alpha_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AlphaValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_alpha_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_alpha_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
+    fn visit_an_plus_b<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusB,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_an_plus_b(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_an_plus_b(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
+    fn visit_an_plus_b_notation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnPlusBNotation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_an_plus_b_notation(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_an_plus_b_notation(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle) {
+    fn visit_angle<'ast: 'r, 'r>(&mut self, node: &'ast Angle, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_angle(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_angle(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
+    fn visit_angle_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnglePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_angle_percentage(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_angle_percentage(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
+    fn visit_any_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AnyNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_any_namespace(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_any_namespace(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
+    fn visit_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_at_rule(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_at_rule(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
+    fn visit_at_rule_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_at_rule_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_at_rule_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
+    fn visit_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AtRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_at_rule_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_at_rule_prelude(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_atom(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_atom(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
+    fn visit_attribute_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_attribute_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_attribute_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
+    fn visit_attribute_selector_matcher<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorMatcher,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_attribute_selector_matcher(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_attribute_selector_matcher(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher_value(
+    fn visit_attribute_selector_matcher_value<'ast: 'r, 'r>(
         &mut self,
-        node: &mut AttributeSelectorMatcherValue,
+        node: &'ast AttributeSelectorMatcherValue,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_attribute_selector_matcher_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_attribute_selector_matcher_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
+    fn visit_attribute_selector_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_attribute_selector_modifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_attribute_selector_modifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
+    fn visit_attribute_selector_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AttributeSelectorValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_attribute_selector_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_attribute_selector_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
+    fn visit_bin_op<'ast: 'r, 'r>(&mut self, node: &'ast BinOp, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_bin_op(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_bin_op(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
+    fn visit_calc_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_operator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_operator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
+    fn visit_calc_operator_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcOperatorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_operator_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_operator_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
+    fn visit_calc_product<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProduct,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_product(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_product(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
+    fn visit_calc_product_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcProductOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_product_or_operator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_product_or_operator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
+    fn visit_calc_product_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcProductOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_product_or_operators(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_product_or_operators(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
+    fn visit_calc_sum<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcSum,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_sum(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_sum(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
+    fn visit_calc_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
+    fn visit_calc_value_or_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CalcValueOrOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_value_or_operator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_value_or_operator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
+    fn visit_calc_value_or_operators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CalcValueOrOperator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_calc_value_or_operators(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_calc_value_or_operators(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
+    fn visit_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
+    fn visit_cmyk_component<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CmykComponent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_cmyk_component(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_cmyk_component(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color) {
+    fn visit_color<'ast: 'r, 'r>(&mut self, node: &'ast Color, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_color(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_color(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
+    fn visit_color_profile_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ColorProfileName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_color_profile_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_color_profile_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
+    fn visit_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Combinator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_combinator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_combinator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
+    fn visit_combinator_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CombinatorValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_combinator_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_combinator_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
+    fn visit_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_complex_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_complex_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
+    fn visit_complex_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComplexSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_complex_selector_children(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_complex_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
+    fn visit_complex_selector_childrens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_complex_selector_childrens(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_complex_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
+    fn visit_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_complex_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_complex_selectors(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
+    fn visit_component_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComponentValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_component_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_component_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
+    fn visit_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ComponentValue],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_component_values(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_component_values(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
+    fn visit_compound_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_compound_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_compound_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
+    fn visit_compound_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CompoundSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_compound_selector_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_compound_selector_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
+    fn visit_compound_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CompoundSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_compound_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_compound_selectors(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
+    fn visit_container_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_condition(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_condition(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
+    fn visit_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
+    fn visit_container_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_query(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_query(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
+    fn visit_container_query_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_query_and(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_query_and(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
+    fn visit_container_query_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_query_not(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_query_not(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
+    fn visit_container_query_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_query_or(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_query_or(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
+    fn visit_container_query_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContainerQueryType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_query_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_query_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
+    fn visit_container_query_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ContainerQueryType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_container_query_types(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_container_query_types(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
+    fn visit_custom_highlight_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomHighlightName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_custom_highlight_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_custom_highlight_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
+    fn visit_custom_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_custom_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_custom_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
+    fn visit_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [CustomIdent],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_custom_idents(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_custom_idents(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
+    fn visit_custom_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_custom_media_query(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_custom_media_query(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
+    fn visit_custom_media_query_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomMediaQueryMediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_custom_media_query_media_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_custom_media_query_media_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
+    fn visit_custom_property_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CustomPropertyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_custom_property_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_custom_property_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
+    fn visit_dashed_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DashedIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_dashed_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_dashed_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
+    fn visit_declaration<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Declaration,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_declaration(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_declaration(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
+    fn visit_declaration_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_declaration_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_declaration_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
+    fn visit_declaration_or_at_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DeclarationOrAtRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_declaration_or_at_rule(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_declaration_or_at_rule(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
+    fn visit_delimiter<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Delimiter,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_delimiter(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_delimiter(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
+    fn visit_delimiter_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DelimiterValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_delimiter_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_delimiter_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
+    fn visit_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Dimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_dimension(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_dimension(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
+    fn visit_dimension_token<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DimensionToken,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_dimension_token(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_dimension_token(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
+    fn visit_document_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DocumentPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_document_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_document_prelude(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_function(
+    fn visit_document_prelude_matching_function<'ast: 'r, 'r>(
         &mut self,
-        node: &mut DocumentPreludeMatchingFunction,
+        node: &'ast DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_document_prelude_matching_function(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_document_prelude_matching_function(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude_matching_functions(
+    fn visit_document_prelude_matching_functions<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        node: &'ast [DocumentPreludeMatchingFunction],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_document_prelude_matching_functions(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_document_prelude_matching_functions(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
+    fn visit_extension_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExtensionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_extension_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_extension_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
+    fn visit_family_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FamilyName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_family_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_family_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
+    fn visit_family_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [FamilyName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_family_names(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_family_names(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex) {
+    fn visit_flex<'ast: 'r, 'r>(&mut self, node: &'ast Flex, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_flex(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_flex(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
+    fn visit_font_feature_values_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FontFeatureValuesPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_font_feature_values_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_font_feature_values_prelude(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
+    fn visit_forgiving_complex_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingComplexSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_forgiving_complex_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_forgiving_complex_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
+    fn visit_forgiving_complex_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ForgivingComplexSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_forgiving_complex_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_forgiving_complex_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
+    fn visit_forgiving_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingRelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_forgiving_relative_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_forgiving_relative_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector_list(
+    fn visit_forgiving_relative_selector_list<'ast: 'r, 'r>(
         &mut self,
-        node: &mut ForgivingRelativeSelectorList,
+        node: &'ast ForgivingRelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_forgiving_relative_selector_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_forgiving_relative_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selectors(
+    fn visit_forgiving_relative_selectors<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<ForgivingRelativeSelector>,
+        node: &'ast [ForgivingRelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_forgiving_relative_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_forgiving_relative_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
+    fn visit_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForgivingSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_forgiving_selector_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_forgiving_selector_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
+    fn visit_frequency<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Frequency,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_frequency(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_frequency(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
+    fn visit_frequency_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FrequencyPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_frequency_percentage(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_frequency_percentage(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_function(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_function(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
+    fn visit_function_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FunctionName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_function_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_function_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
+    fn visit_general_enclosed<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast GeneralEnclosed,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_general_enclosed(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_general_enclosed(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
+    fn visit_hex_color<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast HexColor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_hex_color(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_hex_color(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue) {
+    fn visit_hue<'ast: 'r, 'r>(&mut self, node: &'ast Hue, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_hue(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_hue(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
+    fn visit_id_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_id_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_id_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
+    fn visit_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Ident],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_idents(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_idents(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
+    fn visit_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportConditions,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_conditions(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_conditions(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
+    fn visit_import_href<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportHref,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_href(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_href(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
+    fn visit_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportLayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_layer_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_layer_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
+    fn visit_import_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_prelude(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
+    fn visit_important_flag<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportantFlag,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_important_flag(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_important_flag(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer) {
+    fn visit_integer<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Integer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_integer(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_integer(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
+    fn visit_keyframe_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_keyframe_block(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_keyframe_block(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
+    fn visit_keyframe_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_keyframe_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_keyframe_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
+    fn visit_keyframe_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [KeyframeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_keyframe_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_keyframe_selectors(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
+    fn visit_keyframes_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_keyframes_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_keyframes_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
+    fn visit_keyframes_pseudo_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoFunction,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_keyframes_pseudo_function(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_keyframes_pseudo_function(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
+    fn visit_keyframes_pseudo_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyframesPseudoPrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_keyframes_pseudo_prefix(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
+    fn visit_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_layer_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_layer_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
+    fn visit_layer_name_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerNameList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_layer_name_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_layer_name_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
+    fn visit_layer_names<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [LayerName],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_layer_names(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_layer_names(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
+    fn visit_layer_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LayerPrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_layer_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_layer_prelude(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length) {
+    fn visit_length<'ast: 'r, 'r>(&mut self, node: &'ast Length, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_length(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_length(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
+    fn visit_length_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LengthPercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_length_percentage(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_length_percentage(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
+    fn visit_list_of_component_values<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ListOfComponentValues,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_list_of_component_values(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_list_of_component_values(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
+    fn visit_media_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_and(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_and(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
+    fn visit_media_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_condition(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_condition(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
+    fn visit_media_condition_all_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionAllType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_condition_all_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_condition_all_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
+    fn visit_media_condition_all_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaConditionAllType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_condition_all_types(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_condition_all_types(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
+    fn visit_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_condition_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_condition_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
+    fn visit_media_condition_without_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaConditionWithoutOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_condition_without_or(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_condition_without_or(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_type(
+    fn visit_media_condition_without_or_type<'ast: 'r, 'r>(
         &mut self,
-        node: &mut MediaConditionWithoutOrType,
+        node: &'ast MediaConditionWithoutOrType,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_condition_without_or_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_condition_without_or_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or_types(
+    fn visit_media_condition_without_or_types<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<MediaConditionWithoutOrType>,
+        node: &'ast [MediaConditionWithoutOrType],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_condition_without_or_types(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_condition_without_or_types(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
+    fn visit_media_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
+    fn visit_media_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature_boolean(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature_boolean(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
+    fn visit_media_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
+    fn visit_media_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature_plain(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature_plain(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
+    fn visit_media_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature_range(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature_range(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
+    fn visit_media_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature_range_comparison(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature_range_comparison(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
+    fn visit_media_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature_range_interval(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature_range_interval(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
+    fn visit_media_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_feature_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_feature_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
+    fn visit_media_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_in_parens(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_in_parens(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
+    fn visit_media_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_not(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_not(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
+    fn visit_media_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_or(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_or(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
+    fn visit_media_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_query(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_query(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
+    fn visit_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaQueryList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_query_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_query_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
+    fn visit_media_querys<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [MediaQuery],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_querys(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_querys(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
+    fn visit_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MediaType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_media_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_media_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
+    fn visit_named_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedNamespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_named_namespace(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_named_namespace(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
+    fn visit_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Namespace,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_namespace(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_namespace(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
+    fn visit_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrefix,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_namespace_prefix(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_namespace_prefix(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
+    fn visit_namespace_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_namespace_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_namespace_prelude(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
+    fn visit_namespace_prelude_uri<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamespacePreludeUri,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_namespace_prelude_uri(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_namespace_prelude_uri(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
+    fn visit_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NestingSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_nesting_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_nesting_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_number(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_number(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
+    fn visit_number_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NumberType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_number_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_number_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
+    fn visit_opt_at_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_at_rule_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_at_rule_prelude(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_atom(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_atom(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_matcher(
+    fn visit_opt_attribute_selector_matcher<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorMatcher>,
+        node: &'ast Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_attribute_selector_matcher(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_modifier(
+    fn visit_opt_attribute_selector_modifier<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorModifier>,
+        node: &'ast Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_attribute_selector_modifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_attribute_selector_value(
+    fn visit_opt_attribute_selector_value<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<AttributeSelectorValue>,
+        node: &'ast Option<AttributeSelectorValue>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_attribute_selector_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_attribute_selector_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
+    fn visit_opt_combinator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Combinator>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_combinator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_combinator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
+    fn visit_opt_container_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ContainerName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_container_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_container_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
+    fn visit_opt_forgiving_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ForgivingSelectorList>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_forgiving_selector_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_forgiving_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
+    fn visit_opt_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Function>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_function(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_function(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
+    fn visit_opt_import_conditions<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportConditions>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_import_conditions(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_import_conditions(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
+    fn visit_opt_import_layer_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_import_layer_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_import_layer_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
+    fn visit_opt_important_flag<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ImportantFlag>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_important_flag(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_important_flag(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
+    fn visit_opt_media_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_media_condition_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_media_condition_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
+    fn visit_opt_media_query_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_media_query_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_media_query_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
+    fn visit_opt_media_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<MediaType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_media_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_media_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
+    fn visit_opt_namespace<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Namespace>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_namespace(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_namespace(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
+    fn visit_opt_namespace_prefix<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NamespacePrefix>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_namespace_prefix(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_namespace_prefix(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
+    fn visit_opt_nesting_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<NestingSelector>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_nesting_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_nesting_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
+    fn visit_opt_number<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Number>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_number(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_number(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
+    fn visit_opt_page_selector_pseudos<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_page_selector_pseudos(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_page_selector_pseudos(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
+    fn visit_opt_page_selector_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<PageSelectorType>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_page_selector_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_page_selector_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_class_selector_childrens(
+    fn visit_opt_pseudo_class_selector_childrens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        node: &'ast Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pseudo_element_selector_childrens(
+    fn visit_opt_pseudo_element_selector_childrens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        node: &'ast Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(
+            <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(
                 &mut self.visitor,
                 node,
+                __ast_path,
             )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
+    fn visit_opt_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<SimpleBlock>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_simple_block(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_simple_block(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
+    fn visit_opt_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TypeSelector>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_type_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_type_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
+    fn visit_opt_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_url_modifiers(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_url_modifiers(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
+    fn visit_opt_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<UrlValue>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_url_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_url_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
+    fn visit_page_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_page_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_page_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
+    fn visit_page_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_page_selector_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_page_selector_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
+    fn visit_page_selector_pseudo<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorPseudo,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_page_selector_pseudo(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_page_selector_pseudo(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
+    fn visit_page_selector_pseudos<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelectorPseudo],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_page_selector_pseudos(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_page_selector_pseudos(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
+    fn visit_page_selector_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PageSelectorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_page_selector_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_page_selector_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
+    fn visit_page_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PageSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_page_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_page_selectors(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
+    fn visit_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Percentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_percentage(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_percentage(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
+    fn visit_pseudo_class_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pseudo_class_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pseudo_class_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
+    fn visit_pseudo_class_selector_children<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoClassSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pseudo_class_selector_children(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pseudo_class_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_childrens(
+    fn visit_pseudo_class_selector_childrens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoClassSelectorChildren>,
+        node: &'ast [PseudoClassSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pseudo_class_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
+    fn visit_pseudo_element_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PseudoElementSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pseudo_element_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pseudo_element_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_children(
+    fn visit_pseudo_element_selector_children<'ast: 'r, 'r>(
         &mut self,
-        node: &mut PseudoElementSelectorChildren,
+        node: &'ast PseudoElementSelectorChildren,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pseudo_element_selector_children(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pseudo_element_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector_childrens(
+    fn visit_pseudo_element_selector_childrens<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Vec<PseudoElementSelectorChildren>,
+        node: &'ast [PseudoElementSelectorChildren],
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pseudo_element_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
+    fn visit_qualified_rule<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRule,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_qualified_rule(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_qualified_rule(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
+    fn visit_qualified_rule_prelude<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QualifiedRulePrelude,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_qualified_rule_prelude(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_qualified_rule_prelude(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
+    fn visit_query_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast QueryInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_query_in_parens(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_query_in_parens(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
+    fn visit_ratio<'ast: 'r, 'r>(&mut self, node: &'ast Ratio, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ratio(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ratio(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
+    fn visit_relative_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_relative_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_relative_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
+    fn visit_relative_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RelativeSelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_relative_selector_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_relative_selector_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
+    fn visit_relative_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [RelativeSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_relative_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_relative_selectors(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
+    fn visit_resolution<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Resolution,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_resolution(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_resolution(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule) {
+    fn visit_rule<'ast: 'r, 'r>(&mut self, node: &'ast Rule, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_rule(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_rule(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
+    fn visit_rules<'ast: 'r, 'r>(&mut self, node: &'ast [Rule], __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_rules(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_rules(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
+    fn visit_scope_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ScopeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_scope_range(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_scope_range(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
+    fn visit_selector_list<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SelectorList,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_selector_list(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_selector_list(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
+    fn visit_sequence_of_custom_idents<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SequenceOfCustomIdents,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_sequence_of_custom_idents(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_sequence_of_custom_idents(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
+    fn visit_simple_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_simple_block(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_simple_block(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
+    fn visit_size_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
+    fn visit_size_feature_boolean<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureBoolean,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature_boolean(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature_boolean(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
+    fn visit_size_feature_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
+    fn visit_size_feature_plain<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeaturePlain,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature_plain(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature_plain(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
+    fn visit_size_feature_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature_range(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature_range(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
+    fn visit_size_feature_range_comparison<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeComparison,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature_range_comparison(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature_range_comparison(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
+    fn visit_size_feature_range_interval<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureRangeInterval,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature_range_interval(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature_range_interval(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
+    fn visit_size_feature_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SizeFeatureValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_size_feature_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_size_feature_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_span(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_span(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_str(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_str(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
+    fn visit_style_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StyleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_style_block(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_style_block(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
+    fn visit_stylesheet<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Stylesheet,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_stylesheet(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_stylesheet(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
+    fn visit_subclass_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SubclassSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_subclass_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_subclass_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
+    fn visit_subclass_selectors<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SubclassSelector],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_subclass_selectors(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_subclass_selectors(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
+    fn visit_supports_and<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsAnd,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_and(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_and(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
+    fn visit_supports_condition<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsCondition,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_condition(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_condition(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
+    fn visit_supports_condition_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsConditionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_condition_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_condition_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
+    fn visit_supports_condition_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SupportsConditionType],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_condition_types(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_condition_types(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
+    fn visit_supports_feature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsFeature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_feature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_feature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
+    fn visit_supports_in_parens<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsInParens,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_in_parens(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_in_parens(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
+    fn visit_supports_not<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsNot,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_not(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_not(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
+    fn visit_supports_or<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SupportsOr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_supports_or(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_supports_or(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
+    fn visit_tag_name_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TagNameSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_tag_name_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_tag_name_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time) {
+    fn visit_time<'ast: 'r, 'r>(&mut self, node: &'ast Time, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_time(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_time(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
+    fn visit_time_percentage<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TimePercentage,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_time_percentage(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_time_percentage(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token) {
+    fn visit_token<'ast: 'r, 'r>(&mut self, node: &'ast Token, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_token(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_token(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
+    fn visit_token_and_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TokenAndSpan,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_token_and_span(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_token_and_span(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
+    fn visit_type_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TypeSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_type_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_type_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
+    fn visit_unicode_range<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnicodeRange,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_unicode_range(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_unicode_range(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
+    fn visit_universal_selector<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UniversalSelector,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_universal_selector(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_universal_selector(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
+    fn visit_unknown_dimension<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnknownDimension,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_unknown_dimension(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_unknown_dimension(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url) {
+    fn visit_url<'ast: 'r, 'r>(&mut self, node: &'ast Url, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_url(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_url(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
+    fn visit_url_key_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlKeyValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_url_key_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_url_key_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
+    fn visit_url_modifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlModifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_url_modifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_url_modifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
+    fn visit_url_modifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [UrlModifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_url_modifiers(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_url_modifiers(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
+    fn visit_url_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_url_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_url_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
+    fn visit_url_value_raw<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UrlValueRaw,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_url_value_raw(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_url_value_raw(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
+    fn visit_wq_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WqName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_wq_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_wq_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitMutWith<V: ?Sized + VisitMut> {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait VisitWithAstPath<V: ?Sized + VisitAstPath> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_mut_with(&mut self, visitor: &mut V);
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    );
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_mut_children_with(&mut self, visitor: &mut V);
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    );
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AbsoluteColorBase {
-    #[doc = "Calls [VisitMut`::visit_mut_absolute_color_base`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_absolute_color_base(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AbsoluteColorBase {
+    #[doc = "Calls [VisitAstPath`::visit_absolute_color_base`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_absolute_color_base(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AbsoluteColorBase::HexColor { 0: _field_0 } => {
-                <HexColor as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AbsoluteColorBase(
+                    self,
+                    self::fields::AbsoluteColorBaseField::HexColor,
+                ));
+                <HexColor as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AbsoluteColorBase(
+                    self,
+                    self::fields::AbsoluteColorBaseField::NamedColorOrTransparent,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AbsoluteColorBase::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AbsoluteColorBase(
+                    self,
+                    self::fields::AbsoluteColorBaseField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AlphaValue {
-    #[doc = "Calls [VisitMut`::visit_mut_alpha_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_alpha_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AlphaValue {
+    #[doc = "Calls [VisitAstPath`::visit_alpha_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_alpha_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AlphaValue::Number { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AlphaValue(
+                    self,
+                    self::fields::AlphaValueField::Number,
+                ));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AlphaValue::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AlphaValue(
+                    self,
+                    self::fields::AlphaValueField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnPlusB {
-    #[doc = "Calls [VisitMut`::visit_mut_an_plus_b`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_an_plus_b(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnPlusB {
+    #[doc = "Calls [VisitAstPath`::visit_an_plus_b`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_an_plus_b(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AnPlusB::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusB(
+                    self,
+                    self::fields::AnPlusBField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AnPlusB::AnPlusBNotation { 0: _field_0 } => {
-                <AnPlusBNotation as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusB(
+                    self,
+                    self::fields::AnPlusBField::AnPlusBNotation,
+                ));
+                <AnPlusBNotation as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnPlusBNotation {
-    #[doc = "Calls [VisitMut`::visit_mut_an_plus_b_notation`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_an_plus_b_notation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnPlusBNotation {
+    #[doc = "Calls [VisitAstPath`::visit_an_plus_b_notation`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_an_plus_b_notation(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AnPlusBNotation {
                 span,
@@ -47275,80 +26118,192 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnPlusBNotation {
                 b_raw,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusBNotation(
+                        self,
+                        self::fields::AnPlusBNotationField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(a_raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusBNotation(
+                        self,
+                        self::fields::AnPlusBNotationField::ARaw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        a_raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(b_raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnPlusBNotation(
+                        self,
+                        self::fields::AnPlusBNotationField::BRaw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        b_raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Angle {
-    #[doc = "Calls [VisitMut`::visit_mut_angle`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_angle(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Angle {
+    #[doc = "Calls [VisitAstPath`::visit_angle`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_angle(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Angle { span, value, unit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Angle(
+                        self,
+                        self::fields::AngleField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Angle(
+                        self,
+                        self::fields::AngleField::Value,
+                    ));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Angle(
+                        self,
+                        self::fields::AngleField::Unit,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnglePercentage {
-    #[doc = "Calls [VisitMut`::visit_mut_angle_percentage`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_angle_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnglePercentage {
+    #[doc = "Calls [VisitAstPath`::visit_angle_percentage`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_angle_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AnglePercentage::Angle { 0: _field_0 } => {
-                <Angle as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnglePercentage(
+                    self,
+                    self::fields::AnglePercentageField::Angle,
+                ));
+                <Angle as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AnglePercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnglePercentage(
+                    self,
+                    self::fields::AnglePercentageField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnyNamespace {
-    #[doc = "Calls [VisitMut`::visit_mut_any_namespace`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_any_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AnyNamespace {
+    #[doc = "Calls [VisitAstPath`::visit_any_namespace`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_any_namespace(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AnyNamespace { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AnyNamespace(
+                        self,
+                        self::fields::AnyNamespaceField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AtRule {
-    #[doc = "Calls [VisitMut`::visit_mut_at_rule`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_at_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AtRule {
+    #[doc = "Calls [VisitAstPath`::visit_at_rule`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AtRule {
                 span,
@@ -47357,115 +26312,343 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for AtRule {
                 block,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
+                        self,
+                        self::fields::AtRuleField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <AtRuleName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
+                        self,
+                        self::fields::AtRuleField::Name,
+                    ));
+                    <AtRuleName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<AtRulePrelude>> as VisitMutWith<V>>::visit_mut_with(
-                        prelude, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
+                        self,
+                        self::fields::AtRuleField::Prelude,
+                    ));
+                    <Option<Box<AtRulePrelude>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<SimpleBlock> as VisitMutWith<V>>::visit_mut_with(block, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRule(
+                        self,
+                        self::fields::AtRuleField::Block,
+                    ));
+                    <Option<SimpleBlock> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AtRuleName {
-    #[doc = "Calls [VisitMut`::visit_mut_at_rule_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_at_rule_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AtRuleName {
+    #[doc = "Calls [VisitAstPath`::visit_at_rule_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AtRuleName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRuleName(
+                    self,
+                    self::fields::AtRuleNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRuleName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRuleName(
+                    self,
+                    self::fields::AtRuleNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AtRulePrelude {
-    #[doc = "Calls [VisitMut`::visit_mut_at_rule_prelude`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_at_rule_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AtRulePrelude {
+    #[doc = "Calls [VisitAstPath`::visit_at_rule_prelude`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_at_rule_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AtRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::ListOfComponentValues,
+                ));
+                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::CharsetPrelude { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::CharsetPrelude,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::PropertyPrelude { 0: _field_0 } => {
-                <CustomPropertyName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::PropertyPrelude,
+                ));
+                <CustomPropertyName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::CounterStylePrelude { 0: _field_0 } => {
-                <CustomIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::CounterStylePrelude,
+                ));
+                <CustomIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ColorProfilePrelude { 0: _field_0 } => {
-                <ColorProfileName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::ColorProfilePrelude,
+                ));
+                <ColorProfileName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::DocumentPrelude { 0: _field_0 } => {
-                <DocumentPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::DocumentPrelude,
+                ));
+                <DocumentPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 } => {
-                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::FontPaletteValuesPrelude,
+                ));
+                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 } => {
-                <FontFeatureValuesPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::FontFeatureValuesPrelude,
+                ));
+                <FontFeatureValuesPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::NestPrelude { 0: _field_0 } => {
-                <SelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::NestPrelude,
+                ));
+                <SelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::KeyframesPrelude { 0: _field_0 } => {
-                <KeyframesName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::KeyframesPrelude,
+                ));
+                <KeyframesName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ImportPrelude { 0: _field_0 } => {
-                <ImportPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::ImportPrelude,
+                ));
+                <ImportPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::NamespacePrelude { 0: _field_0 } => {
-                <NamespacePrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::NamespacePrelude,
+                ));
+                <NamespacePrelude as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::MediaPrelude { 0: _field_0 } => {
-                <MediaQueryList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::MediaPrelude,
+                ));
+                <MediaQueryList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::SupportsPrelude { 0: _field_0 } => {
-                <SupportsCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::SupportsPrelude,
+                ));
+                <SupportsCondition as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::PagePrelude { 0: _field_0 } => {
-                <PageSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::PagePrelude,
+                ));
+                <PageSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::LayerPrelude { 0: _field_0 } => {
-                <LayerPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::LayerPrelude,
+                ));
+                <LayerPrelude as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
-                <ContainerCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::ContainerPrelude,
+                ));
+                <ContainerCondition as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::CustomMediaPrelude { 0: _field_0 } => {
-                <CustomMediaQuery as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::CustomMediaPrelude,
+                ));
+                <CustomMediaQuery as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ScopePrelude { 0: _field_0 } => {
-                <ScopeRange as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AtRulePrelude(
+                    self,
+                    self::fields::AtRulePreludeField::ScopePrelude,
+                ));
+                <ScopeRange as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_attribute_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelector {
+    #[doc = "Calls [VisitAstPath`::visit_attribute_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AttributeSelector {
                 span,
@@ -47475,58 +26658,133 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelector {
                 modifier,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
+                            self,
+                            self::fields::AttributeSelectorField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <WqName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
+                            self,
+                            self::fields::AttributeSelectorField::Name,
+                        ));
+                    <WqName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<AttributeSelectorMatcher> as VisitMutWith<V>>::visit_mut_with(
-                        matcher, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
+                            self,
+                            self::fields::AttributeSelectorField::Matcher,
+                        ));
+                    <Option<AttributeSelectorMatcher> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        matcher,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<AttributeSelectorValue> as VisitMutWith<V>>::visit_mut_with(
-                        value, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
+                            self,
+                            self::fields::AttributeSelectorField::Value,
+                        ));
+                    <Option<AttributeSelectorValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<AttributeSelectorModifier> as VisitMutWith<V>>::visit_mut_with(
-                        modifier, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelector(
+                            self,
+                            self::fields::AttributeSelectorField::Modifier,
+                        ));
+                    <Option<AttributeSelectorModifier> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        modifier,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorMatcher {
-    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_matcher`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_attribute_selector_matcher(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorMatcher {
+    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_matcher`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_matcher(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AttributeSelectorMatcher { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorMatcher(
+                            self,
+                            self::fields::AttributeSelectorMatcherField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <AttributeSelectorMatcherValue as VisitMutWith<V>>::visit_mut_with(
-                        value, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorMatcher(
+                            self,
+                            self::fields::AttributeSelectorMatcherField::Value,
+                        ));
+                    <AttributeSelectorMatcherValue as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorMatcherValue {
-    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_matcher_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_attribute_selector_matcher_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorMatcherValue {
+    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_matcher_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_matcher_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AttributeSelectorMatcherValue::Equals => {}
             AttributeSelectorMatcherValue::Tilde => {}
@@ -47537,49 +26795,115 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorMatcherValue {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorModifier {
-    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_modifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_attribute_selector_modifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorModifier {
+    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_modifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_modifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AttributeSelectorModifier { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorModifier(
+                            self,
+                            self::fields::AttributeSelectorModifierField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::AttributeSelectorModifier(
+                            self,
+                            self::fields::AttributeSelectorModifierField::Value,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorValue {
-    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_attribute_selector_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AttributeSelectorValue {
+    #[doc = "Calls [VisitAstPath`::visit_attribute_selector_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_attribute_selector_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AttributeSelectorValue::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::AttributeSelectorValue(
+                        self,
+                        self::fields::AttributeSelectorValueField::Str,
+                    ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AttributeSelectorValue::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::AttributeSelectorValue(
+                        self,
+                        self::fields::AttributeSelectorValueField::Ident,
+                    ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinOp {
-    #[doc = "Calls [VisitMut`::visit_mut_bin_op`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_bin_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinOp {
+    #[doc = "Calls [VisitAstPath`::visit_bin_op`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_bin_op(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BinOp::Add => {}
             BinOp::Sub => {}
@@ -47588,32 +26912,68 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinOp {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcOperator {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_operator`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcOperator {
+    #[doc = "Calls [VisitAstPath`::visit_calc_operator`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_operator(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CalcOperator { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcOperator(
+                        self,
+                        self::fields::CalcOperatorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <CalcOperatorType as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcOperator(
+                        self,
+                        self::fields::CalcOperatorField::Value,
+                    ));
+                    <CalcOperatorType as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcOperatorType {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_operator_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_operator_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcOperatorType {
+    #[doc = "Calls [VisitAstPath`::visit_calc_operator_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_operator_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CalcOperatorType::Add => {}
             CalcOperatorType::Sub => {}
@@ -47622,376 +26982,1018 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcOperatorType {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcProduct {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_product`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_product(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcProduct {
+    #[doc = "Calls [VisitAstPath`::visit_calc_product`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CalcProduct { span, expressions } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcProduct(
+                        self,
+                        self::fields::CalcProductField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<CalcValueOrOperator> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcProduct(
+                        self,
+                        self::fields::CalcProductField::Expressions(usize::MAX),
+                    ));
+                    <Vec<CalcValueOrOperator> as VisitWithAstPath<V>>::visit_with_ast_path(
                         expressions,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcProductOrOperator {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_product_or_operator`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_product_or_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcProductOrOperator {
+    #[doc = "Calls [VisitAstPath`::visit_calc_product_or_operator`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product_or_operator(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CalcProductOrOperator::Product { 0: _field_0 } => {
-                <CalcProduct as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::CalcProductOrOperator(
+                        self,
+                        self::fields::CalcProductOrOperatorField::Product,
+                    ));
+                <CalcProduct as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcProductOrOperator::Operator { 0: _field_0 } => {
-                <CalcOperator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::CalcProductOrOperator(
+                        self,
+                        self::fields::CalcProductOrOperatorField::Operator,
+                    ));
+                <CalcOperator as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcSum {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_sum`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_sum(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcSum {
+    #[doc = "Calls [VisitAstPath`::visit_calc_sum`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_sum(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CalcSum { span, expressions } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcSum(
+                        self,
+                        self::fields::CalcSumField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<CalcProductOrOperator> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcSum(
+                        self,
+                        self::fields::CalcSumField::Expressions(usize::MAX),
+                    ));
+                    <Vec<CalcProductOrOperator> as VisitWithAstPath<V>>::visit_with_ast_path(
                         expressions,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcValue {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcValue {
+    #[doc = "Calls [VisitAstPath`::visit_calc_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CalcValue::Number { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
+                    self,
+                    self::fields::CalcValueField::Number,
+                ));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
+                    self,
+                    self::fields::CalcValueField::Dimension,
+                ));
+                <Dimension as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
+                    self,
+                    self::fields::CalcValueField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Constant { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
+                    self,
+                    self::fields::CalcValueField::Constant,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Sum { 0: _field_0 } => {
-                <CalcSum as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
+                    self,
+                    self::fields::CalcValueField::Sum,
+                ));
+                <CalcSum as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValue(
+                    self,
+                    self::fields::CalcValueField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcValueOrOperator {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_value_or_operator`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_value_or_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CalcValueOrOperator {
+    #[doc = "Calls [VisitAstPath`::visit_calc_value_or_operator`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value_or_operator(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CalcValueOrOperator::Value { 0: _field_0 } => {
-                <CalcValue as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValueOrOperator(
+                    self,
+                    self::fields::CalcValueOrOperatorField::Value,
+                ));
+                <CalcValue as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValueOrOperator::Operator { 0: _field_0 } => {
-                <CalcOperator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CalcValueOrOperator(
+                    self,
+                    self::fields::CalcValueOrOperatorField::Operator,
+                ));
+                <CalcOperator as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_class_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassSelector {
+    #[doc = "Calls [VisitAstPath`::visit_class_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ClassSelector { span, text } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassSelector(
+                        self,
+                        self::fields::ClassSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(text, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassSelector(
+                        self,
+                        self::fields::ClassSelectorField::Text,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        text,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CmykComponent {
-    #[doc = "Calls [VisitMut`::visit_mut_cmyk_component`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_cmyk_component(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CmykComponent {
+    #[doc = "Calls [VisitAstPath`::visit_cmyk_component`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_cmyk_component(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CmykComponent::Number { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CmykComponent(
+                    self,
+                    self::fields::CmykComponentField::Number,
+                ));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CmykComponent::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CmykComponent(
+                    self,
+                    self::fields::CmykComponentField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CmykComponent::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CmykComponent(
+                    self,
+                    self::fields::CmykComponentField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Color {
-    #[doc = "Calls [VisitMut`::visit_mut_color`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_color(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Color {
+    #[doc = "Calls [VisitAstPath`::visit_color`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_color(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Color::AbsoluteColorBase { 0: _field_0 } => {
-                <AbsoluteColorBase as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Color(
+                    self,
+                    self::fields::ColorField::AbsoluteColorBase,
+                ));
+                <AbsoluteColorBase as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Color::CurrentColorOrSystemColor { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Color(
+                    self,
+                    self::fields::ColorField::CurrentColorOrSystemColor,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Color::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Color(
+                    self,
+                    self::fields::ColorField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ColorProfileName {
-    #[doc = "Calls [VisitMut`::visit_mut_color_profile_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_color_profile_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ColorProfileName {
+    #[doc = "Calls [VisitAstPath`::visit_color_profile_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_color_profile_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ColorProfileName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ColorProfileName(
+                    self,
+                    self::fields::ColorProfileNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ColorProfileName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ColorProfileName(
+                    self,
+                    self::fields::ColorProfileNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Combinator {
-    #[doc = "Calls [VisitMut`::visit_mut_combinator`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_combinator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Combinator {
+    #[doc = "Calls [VisitAstPath`::visit_combinator`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_combinator(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Combinator { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Combinator(
+                        self,
+                        self::fields::CombinatorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <CombinatorValue as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Combinator(
+                        self,
+                        self::fields::CombinatorField::Value,
+                    ));
+                    <CombinatorValue as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CombinatorValue {
-    #[doc = "Calls [VisitMut`::visit_mut_combinator_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_combinator_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CombinatorValue {
+    #[doc = "Calls [VisitAstPath`::visit_combinator_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_combinator_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CombinatorValue::Descendant => {}
             CombinatorValue::NextSibling => {}
             CombinatorValue::Child => {}
             CombinatorValue::LaterSibling => {}
             CombinatorValue::Column => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComplexSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_complex_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_complex_selector(visitor, self)
+        }
+    }
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComplexSelector {
+    #[doc = "Calls [VisitAstPath`::visit_complex_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ComplexSelector { span, children } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComplexSelector(
+                        self,
+                        self::fields::ComplexSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ComplexSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
-                        children, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComplexSelector(
+                        self,
+                        self::fields::ComplexSelectorField::Children(usize::MAX),
+                    ));
+                    <Vec<ComplexSelectorChildren> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComplexSelectorChildren {
-    #[doc = "Calls [VisitMut`::visit_mut_complex_selector_children`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_complex_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComplexSelectorChildren {
+    #[doc = "Calls [VisitAstPath`::visit_complex_selector_children`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector_children(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ComplexSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::ComplexSelectorChildren(
+                        self,
+                        self::fields::ComplexSelectorChildrenField::CompoundSelector,
+                    ));
+                <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComplexSelectorChildren::Combinator { 0: _field_0 } => {
-                <Combinator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::ComplexSelectorChildren(
+                        self,
+                        self::fields::ComplexSelectorChildrenField::Combinator,
+                    ));
+                <Combinator as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComponentValue {
-    #[doc = "Calls [VisitMut`::visit_mut_component_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_component_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComponentValue {
+    #[doc = "Calls [VisitAstPath`::visit_component_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_component_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ComponentValue::PreservedToken { 0: _field_0 } => {
-                <Box<TokenAndSpan> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::PreservedToken,
+                ));
+                <Box<TokenAndSpan> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Function { 0: _field_0 } => {
-                <Box<Function> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Function,
+                ));
+                <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::SimpleBlock { 0: _field_0 } => {
-                <Box<SimpleBlock> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::SimpleBlock,
+                ));
+                <Box<SimpleBlock> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::AtRule,
+                ));
+                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::QualifiedRule,
+                ));
+                <Box<QualifiedRule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::KeyframeBlock { 0: _field_0 } => {
-                <Box<KeyframeBlock> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::KeyframeBlock,
+                ));
+                <Box<KeyframeBlock> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Ident { 0: _field_0 } => {
-                <Box<Ident> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Ident,
+                ));
+                <Box<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::DashedIdent { 0: _field_0 } => {
-                <Box<DashedIdent> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::DashedIdent,
+                ));
+                <Box<DashedIdent> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Str { 0: _field_0 } => {
-                <Box<Str> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Str,
+                ));
+                <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Url { 0: _field_0 } => {
-                <Box<Url> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Url,
+                ));
+                <Box<Url> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Integer { 0: _field_0 } => {
-                <Box<Integer> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Integer,
+                ));
+                <Box<Integer> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Number { 0: _field_0 } => {
-                <Box<Number> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Number,
+                ));
+                <Box<Number> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Percentage { 0: _field_0 } => {
-                <Box<Percentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Percentage,
+                ));
+                <Box<Percentage> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Dimension { 0: _field_0 } => {
-                <Box<Dimension> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Dimension,
+                ));
+                <Box<Dimension> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::LengthPercentage { 0: _field_0 } => {
-                <Box<LengthPercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::LengthPercentage,
+                ));
+                <Box<LengthPercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::FrequencyPercentage { 0: _field_0 } => {
-                <Box<FrequencyPercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::FrequencyPercentage,
+                ));
+                <Box<FrequencyPercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::AnglePercentage { 0: _field_0 } => {
-                <Box<AnglePercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::AnglePercentage,
+                ));
+                <Box<AnglePercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::TimePercentage { 0: _field_0 } => {
-                <Box<TimePercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::TimePercentage,
+                ));
+                <Box<TimePercentage> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Ratio { 0: _field_0 } => {
-                <Box<Ratio> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Ratio,
+                ));
+                <Box<Ratio> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::UnicodeRange { 0: _field_0 } => {
-                <Box<UnicodeRange> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::UnicodeRange,
+                ));
+                <Box<UnicodeRange> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Color { 0: _field_0 } => {
-                <Box<Color> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Color,
+                ));
+                <Box<Color> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::AlphaValue { 0: _field_0 } => {
-                <Box<AlphaValue> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::AlphaValue,
+                ));
+                <Box<AlphaValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Hue { 0: _field_0 } => {
-                <Box<Hue> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Hue,
+                ));
+                <Box<Hue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::CmykComponent { 0: _field_0 } => {
-                <Box<CmykComponent> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::CmykComponent,
+                ));
+                <Box<CmykComponent> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Delimiter { 0: _field_0 } => {
-                <Box<Delimiter> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Delimiter,
+                ));
+                <Box<Delimiter> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::CalcSum { 0: _field_0 } => {
-                <Box<CalcSum> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::CalcSum,
+                ));
+                <Box<CalcSum> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::ComplexSelector { 0: _field_0 } => {
-                <Box<ComplexSelector> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::ComplexSelector,
+                ));
+                <Box<ComplexSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::LayerName { 0: _field_0 } => {
-                <Box<LayerName> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::LayerName,
+                ));
+                <Box<LayerName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::SupportsCondition { 0: _field_0 } => {
-                <Box<SupportsCondition> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::SupportsCondition,
+                ));
+                <Box<SupportsCondition> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::Declaration,
+                ));
+                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::IdSelector { 0: _field_0 } => {
-                <Box<IdSelector> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComponentValue(
+                    self,
+                    self::fields::ComponentValueField::IdSelector,
+                ));
+                <Box<IdSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CompoundSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_compound_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_compound_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CompoundSelector {
+    #[doc = "Calls [VisitAstPath`::visit_compound_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CompoundSelector {
                 span,
@@ -48000,111 +28002,253 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for CompoundSelector {
                 subclass_selectors,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
+                        self,
+                        self::fields::CompoundSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<NestingSelector> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
+                        self,
+                        self::fields::CompoundSelectorField::NestingSelector,
+                    ));
+                    <Option<NestingSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
                         nesting_selector,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<Box<TypeSelector>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
+                        self,
+                        self::fields::CompoundSelectorField::TypeSelector,
+                    ));
+                    <Option<Box<TypeSelector>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_selector,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Vec<SubclassSelector> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CompoundSelector(
+                        self,
+                        self::fields::CompoundSelectorField::SubclassSelectors(usize::MAX),
+                    ));
+                    <Vec<SubclassSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
                         subclass_selectors,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CompoundSelectorList {
-    #[doc = "Calls [VisitMut`::visit_mut_compound_selector_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_compound_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CompoundSelectorList {
+    #[doc = "Calls [VisitAstPath`::visit_compound_selector_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CompoundSelectorList { span, children } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CompoundSelectorList(
+                            self,
+                            self::fields::CompoundSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<CompoundSelector> as VisitMutWith<V>>::visit_mut_with(children, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CompoundSelectorList(
+                            self,
+                            self::fields::CompoundSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<CompoundSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerCondition {
-    #[doc = "Calls [VisitMut`::visit_mut_container_condition`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerCondition {
+    #[doc = "Calls [VisitAstPath`::visit_container_condition`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_condition(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContainerCondition { span, name, query } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerCondition(
+                            self,
+                            self::fields::ContainerConditionField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<ContainerName> as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerCondition(
+                            self,
+                            self::fields::ContainerConditionField::Name,
+                        ));
+                    <Option<ContainerName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ContainerQuery as VisitMutWith<V>>::visit_mut_with(query, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerCondition(
+                            self,
+                            self::fields::ContainerConditionField::Query,
+                        ));
+                    <ContainerQuery as VisitWithAstPath<V>>::visit_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerName {
-    #[doc = "Calls [VisitMut`::visit_mut_container_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerName {
+    #[doc = "Calls [VisitAstPath`::visit_container_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContainerName::CustomIdent { 0: _field_0 } => {
-                <CustomIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerName(
+                    self,
+                    self::fields::ContainerNameField::CustomIdent,
+                ));
+                <CustomIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQuery {
-    #[doc = "Calls [VisitMut`::visit_mut_container_query`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQuery {
+    #[doc = "Calls [VisitAstPath`::visit_container_query`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContainerQuery { span, queries } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQuery(
+                        self,
+                        self::fields::ContainerQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ContainerQueryType> as VisitMutWith<V>>::visit_mut_with(queries, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQuery(
+                        self,
+                        self::fields::ContainerQueryField::Queries(usize::MAX),
+                    ));
+                    <Vec<ContainerQueryType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        queries,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryAnd {
-    #[doc = "Calls [VisitMut`::visit_mut_container_query_and`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_query_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryAnd {
+    #[doc = "Calls [VisitAstPath`::visit_container_query_and`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_and(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContainerQueryAnd {
                 span,
@@ -48112,25 +28256,62 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryAnd {
                 query,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryAnd(
+                            self,
+                            self::fields::ContainerQueryAndField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryAnd(
+                            self,
+                            self::fields::ContainerQueryAndField::Keyword,
+                        ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <QueryInParens as VisitMutWith<V>>::visit_mut_with(query, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryAnd(
+                            self,
+                            self::fields::ContainerQueryAndField::Query,
+                        ));
+                    <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryNot {
-    #[doc = "Calls [VisitMut`::visit_mut_container_query_not`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_query_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryNot {
+    #[doc = "Calls [VisitAstPath`::visit_container_query_not`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_not(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContainerQueryNot {
                 span,
@@ -48138,25 +28319,62 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryNot {
                 query,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryNot(
+                            self,
+                            self::fields::ContainerQueryNotField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryNot(
+                            self,
+                            self::fields::ContainerQueryNotField::Keyword,
+                        ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <QueryInParens as VisitMutWith<V>>::visit_mut_with(query, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ContainerQueryNot(
+                            self,
+                            self::fields::ContainerQueryNotField::Query,
+                        ));
+                    <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryOr {
-    #[doc = "Calls [VisitMut`::visit_mut_container_query_or`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_query_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryOr {
+    #[doc = "Calls [VisitAstPath`::visit_container_query_or`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_or(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContainerQueryOr {
                 span,
@@ -48164,175 +28382,455 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryOr {
                 query,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryOr(
+                        self,
+                        self::fields::ContainerQueryOrField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryOr(
+                        self,
+                        self::fields::ContainerQueryOrField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <QueryInParens as VisitMutWith<V>>::visit_mut_with(query, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryOr(
+                        self,
+                        self::fields::ContainerQueryOrField::Query,
+                    ));
+                    <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryType {
-    #[doc = "Calls [VisitMut`::visit_mut_container_query_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_query_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContainerQueryType {
+    #[doc = "Calls [VisitAstPath`::visit_container_query_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContainerQueryType::Not { 0: _field_0 } => {
-                <ContainerQueryNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
+                    self,
+                    self::fields::ContainerQueryTypeField::Not,
+                ));
+                <ContainerQueryNot as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ContainerQueryType::And { 0: _field_0 } => {
-                <ContainerQueryAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
+                    self,
+                    self::fields::ContainerQueryTypeField::And,
+                ));
+                <ContainerQueryAnd as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ContainerQueryType::Or { 0: _field_0 } => {
-                <ContainerQueryOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
+                    self,
+                    self::fields::ContainerQueryTypeField::Or,
+                ));
+                <ContainerQueryOr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ContainerQueryType::QueryInParens { 0: _field_0 } => {
-                <QueryInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContainerQueryType(
+                    self,
+                    self::fields::ContainerQueryTypeField::QueryInParens,
+                ));
+                <QueryInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomHighlightName {
-    #[doc = "Calls [VisitMut`::visit_mut_custom_highlight_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_custom_highlight_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomHighlightName {
+    #[doc = "Calls [VisitAstPath`::visit_custom_highlight_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_highlight_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CustomHighlightName { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CustomHighlightName(
+                            self,
+                            self::fields::CustomHighlightNameField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CustomHighlightName(
+                            self,
+                            self::fields::CustomHighlightNameField::Value,
+                        ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CustomHighlightName(
+                            self,
+                            self::fields::CustomHighlightNameField::Raw,
+                        ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomIdent {
-    #[doc = "Calls [VisitMut`::visit_mut_custom_ident`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_custom_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomIdent {
+    #[doc = "Calls [VisitAstPath`::visit_custom_ident`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_ident(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CustomIdent { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomIdent(
+                        self,
+                        self::fields::CustomIdentField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomIdent(
+                        self,
+                        self::fields::CustomIdentField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomIdent(
+                        self,
+                        self::fields::CustomIdentField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomMediaQuery {
-    #[doc = "Calls [VisitMut`::visit_mut_custom_media_query`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_custom_media_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomMediaQuery {
+    #[doc = "Calls [VisitAstPath`::visit_custom_media_query`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_media_query(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CustomMediaQuery { span, name, media } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomMediaQuery(
+                        self,
+                        self::fields::CustomMediaQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ExtensionName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomMediaQuery(
+                        self,
+                        self::fields::CustomMediaQueryField::Name,
+                    ));
+                    <ExtensionName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <CustomMediaQueryMediaType as VisitMutWith<V>>::visit_mut_with(media, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CustomMediaQuery(
+                        self,
+                        self::fields::CustomMediaQueryField::Media,
+                    ));
+                    <CustomMediaQueryMediaType as VisitWithAstPath<V>>::visit_with_ast_path(
+                        media,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomMediaQueryMediaType {
-    #[doc = "Calls [VisitMut`::visit_mut_custom_media_query_media_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_custom_media_query_media_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomMediaQueryMediaType {
+    #[doc = "Calls [VisitAstPath`::visit_custom_media_query_media_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_media_query_media_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CustomMediaQueryMediaType::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::CustomMediaQueryMediaType(
+                        self,
+                        self::fields::CustomMediaQueryMediaTypeField::Ident,
+                    ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 } => {
-                <MediaQueryList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::CustomMediaQueryMediaType(
+                        self,
+                        self::fields::CustomMediaQueryMediaTypeField::MediaQueryList,
+                    ));
+                <MediaQueryList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomPropertyName {
-    #[doc = "Calls [VisitMut`::visit_mut_custom_property_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_custom_property_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CustomPropertyName {
+    #[doc = "Calls [VisitAstPath`::visit_custom_property_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_property_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CustomPropertyName { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CustomPropertyName(
+                            self,
+                            self::fields::CustomPropertyNameField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CustomPropertyName(
+                            self,
+                            self::fields::CustomPropertyNameField::Value,
+                        ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::CustomPropertyName(
+                            self,
+                            self::fields::CustomPropertyNameField::Raw,
+                        ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DashedIdent {
-    #[doc = "Calls [VisitMut`::visit_mut_dashed_ident`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_dashed_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DashedIdent {
+    #[doc = "Calls [VisitAstPath`::visit_dashed_ident`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dashed_ident(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DashedIdent { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DashedIdent(
+                        self,
+                        self::fields::DashedIdentField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DashedIdent(
+                        self,
+                        self::fields::DashedIdentField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DashedIdent(
+                        self,
+                        self::fields::DashedIdentField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Declaration {
-    #[doc = "Calls [VisitMut`::visit_mut_declaration`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_declaration(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Declaration {
+    #[doc = "Calls [VisitAstPath`::visit_declaration`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Declaration {
                 span,
@@ -48341,84 +28839,212 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Declaration {
                 important,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
+                        self,
+                        self::fields::DeclarationField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <DeclarationName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
+                        self,
+                        self::fields::DeclarationField::Name,
+                    ));
+                    <DeclarationName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
+                        self,
+                        self::fields::DeclarationField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<ImportantFlag> as VisitMutWith<V>>::visit_mut_with(important, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Declaration(
+                        self,
+                        self::fields::DeclarationField::Important,
+                    ));
+                    <Option<ImportantFlag> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        important,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DeclarationName {
-    #[doc = "Calls [VisitMut`::visit_mut_declaration_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_declaration_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DeclarationName {
+    #[doc = "Calls [VisitAstPath`::visit_declaration_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DeclarationName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationName(
+                    self,
+                    self::fields::DeclarationNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DeclarationName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationName(
+                    self,
+                    self::fields::DeclarationNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DeclarationOrAtRule {
-    #[doc = "Calls [VisitMut`::visit_mut_declaration_or_at_rule`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_declaration_or_at_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DeclarationOrAtRule {
+    #[doc = "Calls [VisitAstPath`::visit_declaration_or_at_rule`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_declaration_or_at_rule(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DeclarationOrAtRule::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationOrAtRule(
+                    self,
+                    self::fields::DeclarationOrAtRuleField::Declaration,
+                ));
+                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DeclarationOrAtRule::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationOrAtRule(
+                    self,
+                    self::fields::DeclarationOrAtRuleField::AtRule,
+                ));
+                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DeclarationOrAtRule(
+                    self,
+                    self::fields::DeclarationOrAtRuleField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Delimiter {
-    #[doc = "Calls [VisitMut`::visit_mut_delimiter`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_delimiter(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Delimiter {
+    #[doc = "Calls [VisitAstPath`::visit_delimiter`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_delimiter(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Delimiter { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Delimiter(
+                        self,
+                        self::fields::DelimiterField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <DelimiterValue as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Delimiter(
+                        self,
+                        self::fields::DelimiterField::Value,
+                    ));
+                    <DelimiterValue as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DelimiterValue {
-    #[doc = "Calls [VisitMut`::visit_mut_delimiter_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_delimiter_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DelimiterValue {
+    #[doc = "Calls [VisitAstPath`::visit_delimiter_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_delimiter_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DelimiterValue::Comma => {}
             DelimiterValue::Solidus => {}
@@ -48426,45 +29052,121 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for DelimiterValue {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Dimension {
-    #[doc = "Calls [VisitMut`::visit_mut_dimension`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_dimension(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Dimension {
+    #[doc = "Calls [VisitAstPath`::visit_dimension`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dimension(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Dimension::Length { 0: _field_0 } => {
-                <Length as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
+                    self,
+                    self::fields::DimensionField::Length,
+                ));
+                <Length as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Angle { 0: _field_0 } => {
-                <Angle as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
+                    self,
+                    self::fields::DimensionField::Angle,
+                ));
+                <Angle as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Time { 0: _field_0 } => {
-                <Time as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
+                    self,
+                    self::fields::DimensionField::Time,
+                ));
+                <Time as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Frequency { 0: _field_0 } => {
-                <Frequency as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
+                    self,
+                    self::fields::DimensionField::Frequency,
+                ));
+                <Frequency as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Resolution { 0: _field_0 } => {
-                <Resolution as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
+                    self,
+                    self::fields::DimensionField::Resolution,
+                ));
+                <Resolution as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Flex { 0: _field_0 } => {
-                <Flex as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
+                    self,
+                    self::fields::DimensionField::Flex,
+                ));
+                <Flex as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::UnknownDimension { 0: _field_0 } => {
-                <UnknownDimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Dimension(
+                    self,
+                    self::fields::DimensionField::UnknownDimension,
+                ));
+                <UnknownDimension as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DimensionToken {
-    #[doc = "Calls [VisitMut`::visit_mut_dimension_token`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_dimension_token(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DimensionToken {
+    #[doc = "Calls [VisitAstPath`::visit_dimension_token`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_dimension_token(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DimensionToken {
                 value,
@@ -48474,401 +29176,974 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for DimensionToken {
                 raw_unit,
             } => {
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw_value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
+                        self,
+                        self::fields::DimensionTokenField::RawValue,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw_value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
+                        self,
+                        self::fields::DimensionTokenField::Unit,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <NumberType as VisitMutWith<V>>::visit_mut_with(type_flag, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
+                        self,
+                        self::fields::DimensionTokenField::TypeFlag,
+                    ));
+                    <NumberType as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_flag,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw_unit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DimensionToken(
+                        self,
+                        self::fields::DimensionTokenField::RawUnit,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw_unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DocumentPrelude {
-    #[doc = "Calls [VisitMut`::visit_mut_document_prelude`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_document_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DocumentPrelude {
+    #[doc = "Calls [VisitAstPath`::visit_document_prelude`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DocumentPrelude {
                 span,
-                matching_functions,
-            } => {
-                {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
-                };
+                matching_functions,
+            } => {
                 {
-                    <Vec<DocumentPreludeMatchingFunction> as VisitMutWith<V>>::visit_mut_with(
-                        matching_functions,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DocumentPrelude(
+                        self,
+                        self::fields::DocumentPreludeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DocumentPrelude(
+                        self,
+                        self::fields::DocumentPreludeField::MatchingFunctions(usize::MAX),
+                    ));
+                    < Vec < DocumentPreludeMatchingFunction > as VisitWithAstPath < V > > :: visit_with_ast_path (matching_functions , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DocumentPreludeMatchingFunction {
-    #[doc = "Calls [VisitMut`::visit_mut_document_prelude_matching_function`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_document_prelude_matching_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DocumentPreludeMatchingFunction {
+    #[doc = "Calls [VisitAstPath`::visit_document_prelude_matching_function`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude_matching_function(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DocumentPreludeMatchingFunction::Url { 0: _field_0 } => {
-                <Url as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::DocumentPreludeMatchingFunction(
+                        self,
+                        self::fields::DocumentPreludeMatchingFunctionField::Url,
+                    ));
+                <Url as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DocumentPreludeMatchingFunction::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::DocumentPreludeMatchingFunction(
+                        self,
+                        self::fields::DocumentPreludeMatchingFunctionField::Function,
+                    ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExtensionName {
-    #[doc = "Calls [VisitMut`::visit_mut_extension_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_extension_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExtensionName {
+    #[doc = "Calls [VisitAstPath`::visit_extension_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_extension_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExtensionName { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExtensionName(
+                        self,
+                        self::fields::ExtensionNameField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExtensionName(
+                        self,
+                        self::fields::ExtensionNameField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExtensionName(
+                        self,
+                        self::fields::ExtensionNameField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for FamilyName {
-    #[doc = "Calls [VisitMut`::visit_mut_family_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_family_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FamilyName {
+    #[doc = "Calls [VisitAstPath`::visit_family_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_family_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             FamilyName::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FamilyName(
+                    self,
+                    self::fields::FamilyNameField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             FamilyName::SequenceOfCustomIdents { 0: _field_0 } => {
-                <SequenceOfCustomIdents as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FamilyName(
+                    self,
+                    self::fields::FamilyNameField::SequenceOfCustomIdents,
+                ));
+                <SequenceOfCustomIdents as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Flex {
-    #[doc = "Calls [VisitMut`::visit_mut_flex`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_flex(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Flex {
+    #[doc = "Calls [VisitAstPath`::visit_flex`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_flex(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Flex { span, value, unit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Flex(self, self::fields::FlexField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Flex(self, self::fields::FlexField::Value));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Flex(self, self::fields::FlexField::Unit));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for FontFeatureValuesPrelude {
-    #[doc = "Calls [VisitMut`::visit_mut_font_feature_values_prelude`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_font_feature_values_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FontFeatureValuesPrelude {
+    #[doc = "Calls [VisitAstPath`::visit_font_feature_values_prelude`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_font_feature_values_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             FontFeatureValuesPrelude { span, font_family } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::FontFeatureValuesPrelude(
+                            self,
+                            self::fields::FontFeatureValuesPreludeField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<FamilyName> as VisitMutWith<V>>::visit_mut_with(font_family, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::FontFeatureValuesPrelude(
+                            self,
+                            self::fields::FontFeatureValuesPreludeField::FontFamily(usize::MAX),
+                        ));
+                    <Vec<FamilyName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        font_family,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingComplexSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_forgiving_complex_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_forgiving_complex_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingComplexSelector {
+    #[doc = "Calls [VisitAstPath`::visit_forgiving_complex_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_complex_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForgivingComplexSelector::ComplexSelector { 0: _field_0 } => {
-                <ComplexSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::ForgivingComplexSelector(
+                        self,
+                        self::fields::ForgivingComplexSelectorField::ComplexSelector,
+                    ));
+                <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::ForgivingComplexSelector(
+                        self,
+                        self::fields::ForgivingComplexSelectorField::ListOfComponentValues,
+                    ));
+                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingRelativeSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_forgiving_relative_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingRelativeSelector {
+    #[doc = "Calls [VisitAstPath`::visit_forgiving_relative_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForgivingRelativeSelector::RelativeSelector { 0: _field_0 } => {
-                <RelativeSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelector(
+                        self,
+                        self::fields::ForgivingRelativeSelectorField::RelativeSelector,
+                    ));
+                <RelativeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelector(
+                        self,
+                        self::fields::ForgivingRelativeSelectorField::ListOfComponentValues,
+                    ));
+                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingRelativeSelectorList {
-    #[doc = "Calls [VisitMut`::visit_mut_forgiving_relative_selector_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingRelativeSelectorList {
+    #[doc = "Calls [VisitAstPath`::visit_forgiving_relative_selector_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForgivingRelativeSelectorList { span, children } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelectorList(
+                            self,
+                            self::fields::ForgivingRelativeSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ForgivingRelativeSelector> as VisitMutWith<V>>::visit_mut_with(
-                        children, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ForgivingRelativeSelectorList(
+                            self,
+                            self::fields::ForgivingRelativeSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<ForgivingRelativeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingSelectorList {
-    #[doc = "Calls [VisitMut`::visit_mut_forgiving_selector_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_forgiving_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForgivingSelectorList {
+    #[doc = "Calls [VisitAstPath`::visit_forgiving_selector_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForgivingSelectorList { span, children } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ForgivingSelectorList(
+                            self,
+                            self::fields::ForgivingSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ForgivingComplexSelector> as VisitMutWith<V>>::visit_mut_with(
-                        children, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ForgivingSelectorList(
+                            self,
+                            self::fields::ForgivingSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<ForgivingComplexSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Frequency {
-    #[doc = "Calls [VisitMut`::visit_mut_frequency`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_frequency(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Frequency {
+    #[doc = "Calls [VisitAstPath`::visit_frequency`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_frequency(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Frequency { span, value, unit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Frequency(
+                        self,
+                        self::fields::FrequencyField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Frequency(
+                        self,
+                        self::fields::FrequencyField::Value,
+                    ));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Frequency(
+                        self,
+                        self::fields::FrequencyField::Unit,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for FrequencyPercentage {
-    #[doc = "Calls [VisitMut`::visit_mut_frequency_percentage`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_frequency_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FrequencyPercentage {
+    #[doc = "Calls [VisitAstPath`::visit_frequency_percentage`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_frequency_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             FrequencyPercentage::Frequency { 0: _field_0 } => {
-                <Frequency as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FrequencyPercentage(
+                    self,
+                    self::fields::FrequencyPercentageField::Frequency,
+                ));
+                <Frequency as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             FrequencyPercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FrequencyPercentage(
+                    self,
+                    self::fields::FrequencyPercentageField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Function {
-    #[doc = "Calls [VisitMut`::visit_mut_function`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Function {
+    #[doc = "Calls [VisitAstPath`::visit_function`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Function { span, name, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <FunctionName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Name,
+                    ));
+                    <FunctionName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for FunctionName {
-    #[doc = "Calls [VisitMut`::visit_mut_function_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_function_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FunctionName {
+    #[doc = "Calls [VisitAstPath`::visit_function_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             FunctionName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FunctionName(
+                    self,
+                    self::fields::FunctionNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             FunctionName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FunctionName(
+                    self,
+                    self::fields::FunctionNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for GeneralEnclosed {
-    #[doc = "Calls [VisitMut`::visit_mut_general_enclosed`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_general_enclosed(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for GeneralEnclosed {
+    #[doc = "Calls [VisitAstPath`::visit_general_enclosed`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_general_enclosed(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             GeneralEnclosed::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GeneralEnclosed(
+                    self,
+                    self::fields::GeneralEnclosedField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             GeneralEnclosed::SimpleBlock { 0: _field_0 } => {
-                <SimpleBlock as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GeneralEnclosed(
+                    self,
+                    self::fields::GeneralEnclosedField::SimpleBlock,
+                ));
+                <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for HexColor {
-    #[doc = "Calls [VisitMut`::visit_mut_hex_color`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_hex_color(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for HexColor {
+    #[doc = "Calls [VisitAstPath`::visit_hex_color`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_hex_color(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             HexColor { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::HexColor(
+                        self,
+                        self::fields::HexColorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::HexColor(
+                        self,
+                        self::fields::HexColorField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::HexColor(
+                        self,
+                        self::fields::HexColorField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Hue {
-    #[doc = "Calls [VisitMut`::visit_mut_hue`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_hue(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Hue {
+    #[doc = "Calls [VisitAstPath`::visit_hue`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_hue(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Hue::Number { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Hue(self, self::fields::HueField::Number));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Hue::Angle { 0: _field_0 } => {
-                <Angle as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Hue(self, self::fields::HueField::Angle));
+                <Angle as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for IdSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_id_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_id_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for IdSelector {
+    #[doc = "Calls [VisitAstPath`::visit_id_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_id_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             IdSelector { span, text } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdSelector(
+                        self,
+                        self::fields::IdSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(text, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdSelector(
+                        self,
+                        self::fields::IdSelectorField::Text,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        text,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Ident {
-    #[doc = "Calls [VisitMut`::visit_mut_ident`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Ident {
+    #[doc = "Calls [VisitAstPath`::visit_ident`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ident(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Ident { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
+                        self,
+                        self::fields::IdentField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
+                        self,
+                        self::fields::IdentField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Ident(self, self::fields::IdentField::Raw));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportConditions {
-    #[doc = "Calls [VisitMut`::visit_mut_import_conditions`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_conditions(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportConditions {
+    #[doc = "Calls [VisitAstPath`::visit_import_conditions`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_conditions(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportConditions {
                 span,
@@ -48876,59 +30151,145 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportConditions {
                 media,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportConditions(
+                        self,
+                        self::fields::ImportConditionsField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Function>> as VisitMutWith<V>>::visit_mut_with(supports, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportConditions(
+                        self,
+                        self::fields::ImportConditionsField::Supports,
+                    ));
+                    <Option<Box<Function>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        supports,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<MediaQueryList>> as VisitMutWith<V>>::visit_mut_with(media, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportConditions(
+                        self,
+                        self::fields::ImportConditionsField::Media,
+                    ));
+                    <Option<Box<MediaQueryList>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        media,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportHref {
-    #[doc = "Calls [VisitMut`::visit_mut_import_href`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_href(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportHref {
+    #[doc = "Calls [VisitAstPath`::visit_import_href`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_href(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportHref::Url { 0: _field_0 } => {
-                <Url as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportHref(
+                    self,
+                    self::fields::ImportHrefField::Url,
+                ));
+                <Url as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportHref::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportHref(
+                    self,
+                    self::fields::ImportHrefField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportLayerName {
-    #[doc = "Calls [VisitMut`::visit_mut_import_layer_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_layer_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportLayerName {
+    #[doc = "Calls [VisitAstPath`::visit_import_layer_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_layer_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportLayerName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportLayerName(
+                    self,
+                    self::fields::ImportLayerNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportLayerName::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportLayerName(
+                    self,
+                    self::fields::ImportLayerNameField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportPrelude {
-    #[doc = "Calls [VisitMut`::visit_mut_import_prelude`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportPrelude {
+    #[doc = "Calls [VisitAstPath`::visit_import_prelude`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportPrelude {
                 span,
@@ -48937,71 +30298,160 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportPrelude {
                 import_conditions,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
+                        self,
+                        self::fields::ImportPreludeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<ImportHref> as VisitMutWith<V>>::visit_mut_with(href, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
+                        self,
+                        self::fields::ImportPreludeField::Href,
+                    ));
+                    <Box<ImportHref> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        href,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<ImportLayerName>> as VisitMutWith<V>>::visit_mut_with(
-                        layer_name, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
+                        self,
+                        self::fields::ImportPreludeField::LayerName,
+                    ));
+                    <Option<Box<ImportLayerName>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        layer_name,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<Box<ImportConditions>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportPrelude(
+                        self,
+                        self::fields::ImportPreludeField::ImportConditions,
+                    ));
+                    <Option<Box<ImportConditions>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         import_conditions,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportantFlag {
-    #[doc = "Calls [VisitMut`::visit_mut_important_flag`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_important_flag(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportantFlag {
+    #[doc = "Calls [VisitAstPath`::visit_important_flag`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_important_flag(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportantFlag { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportantFlag(
+                        self,
+                        self::fields::ImportantFlagField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportantFlag(
+                        self,
+                        self::fields::ImportantFlagField::Value,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Integer {
-    #[doc = "Calls [VisitMut`::visit_mut_integer`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_integer(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Integer {
+    #[doc = "Calls [VisitAstPath`::visit_integer`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_integer(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Integer { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Integer(
+                        self,
+                        self::fields::IntegerField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Integer(
+                        self,
+                        self::fields::IntegerField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframeBlock {
-    #[doc = "Calls [VisitMut`::visit_mut_keyframe_block`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_keyframe_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframeBlock {
+    #[doc = "Calls [VisitAstPath`::visit_keyframe_block`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_block(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             KeyframeBlock {
                 span,
@@ -49009,224 +30459,564 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframeBlock {
                 block,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeBlock(
+                        self,
+                        self::fields::KeyframeBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<KeyframeSelector> as VisitMutWith<V>>::visit_mut_with(prelude, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeBlock(
+                        self,
+                        self::fields::KeyframeBlockField::Prelude(usize::MAX),
+                    ));
+                    <Vec<KeyframeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SimpleBlock as VisitMutWith<V>>::visit_mut_with(block, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeBlock(
+                        self,
+                        self::fields::KeyframeBlockField::Block,
+                    ));
+                    <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframeSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_keyframe_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_keyframe_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframeSelector {
+    #[doc = "Calls [VisitAstPath`::visit_keyframe_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             KeyframeSelector::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeSelector(
+                    self,
+                    self::fields::KeyframeSelectorField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframeSelector::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframeSelector(
+                    self,
+                    self::fields::KeyframeSelectorField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframesName {
-    #[doc = "Calls [VisitMut`::visit_mut_keyframes_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_keyframes_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframesName {
+    #[doc = "Calls [VisitAstPath`::visit_keyframes_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             KeyframesName::CustomIdent { 0: _field_0 } => {
-                <Box<CustomIdent> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
+                    self,
+                    self::fields::KeyframesNameField::CustomIdent,
+                ));
+                <Box<CustomIdent> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframesName::Str { 0: _field_0 } => {
-                <Box<Str> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
+                    self,
+                    self::fields::KeyframesNameField::Str,
+                ));
+                <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframesName::PseudoPrefix { 0: _field_0 } => {
-                <Box<KeyframesPseudoPrefix> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
+                    self,
+                    self::fields::KeyframesNameField::PseudoPrefix,
+                ));
+                <Box<KeyframesPseudoPrefix> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframesName::PseudoFunction { 0: _field_0 } => {
-                <Box<KeyframesPseudoFunction> as VisitMutWith<V>>::visit_mut_with(
-                    _field_0, visitor,
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyframesName(
+                    self,
+                    self::fields::KeyframesNameField::PseudoFunction,
+                ));
+                <Box<KeyframesPseudoFunction> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
                 );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframesPseudoFunction {
-    #[doc = "Calls [VisitMut`::visit_mut_keyframes_pseudo_function`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_keyframes_pseudo_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframesPseudoFunction {
+    #[doc = "Calls [VisitAstPath`::visit_keyframes_pseudo_function`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_pseudo_function(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             KeyframesPseudoFunction { span, pseudo, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoFunction(
+                            self,
+                            self::fields::KeyframesPseudoFunctionField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(pseudo, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoFunction(
+                            self,
+                            self::fields::KeyframesPseudoFunctionField::Pseudo,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        pseudo,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <KeyframesName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoFunction(
+                            self,
+                            self::fields::KeyframesPseudoFunctionField::Name,
+                        ));
+                    <KeyframesName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframesPseudoPrefix {
-    #[doc = "Calls [VisitMut`::visit_mut_keyframes_pseudo_prefix`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyframesPseudoPrefix {
+    #[doc = "Calls [VisitAstPath`::visit_keyframes_pseudo_prefix`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframes_pseudo_prefix(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             KeyframesPseudoPrefix { span, pseudo, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoPrefix(
+                            self,
+                            self::fields::KeyframesPseudoPrefixField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(pseudo, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoPrefix(
+                            self,
+                            self::fields::KeyframesPseudoPrefixField::Pseudo,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        pseudo,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <KeyframesName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::KeyframesPseudoPrefix(
+                            self,
+                            self::fields::KeyframesPseudoPrefixField::Name,
+                        ));
+                    <KeyframesName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for LayerName {
-    #[doc = "Calls [VisitMut`::visit_mut_layer_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_layer_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LayerName {
+    #[doc = "Calls [VisitAstPath`::visit_layer_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             LayerName { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerName(
+                        self,
+                        self::fields::LayerNameField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Ident> as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerName(
+                        self,
+                        self::fields::LayerNameField::Name(usize::MAX),
+                    ));
+                    <Vec<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for LayerNameList {
-    #[doc = "Calls [VisitMut`::visit_mut_layer_name_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_layer_name_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LayerNameList {
+    #[doc = "Calls [VisitAstPath`::visit_layer_name_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_name_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             LayerNameList { span, name_list } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerNameList(
+                        self,
+                        self::fields::LayerNameListField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<LayerName> as VisitMutWith<V>>::visit_mut_with(name_list, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerNameList(
+                        self,
+                        self::fields::LayerNameListField::NameList(usize::MAX),
+                    ));
+                    <Vec<LayerName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name_list,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for LayerPrelude {
-    #[doc = "Calls [VisitMut`::visit_mut_layer_prelude`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_layer_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LayerPrelude {
+    #[doc = "Calls [VisitAstPath`::visit_layer_prelude`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             LayerPrelude::Name { 0: _field_0 } => {
-                <LayerName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerPrelude(
+                    self,
+                    self::fields::LayerPreludeField::Name,
+                ));
+                <LayerName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             LayerPrelude::NameList { 0: _field_0 } => {
-                <LayerNameList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LayerPrelude(
+                    self,
+                    self::fields::LayerPreludeField::NameList,
+                ));
+                <LayerNameList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Length {
-    #[doc = "Calls [VisitMut`::visit_mut_length`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_length(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Length {
+    #[doc = "Calls [VisitAstPath`::visit_length`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_length(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Length { span, value, unit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Length(
+                        self,
+                        self::fields::LengthField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Length(
+                        self,
+                        self::fields::LengthField::Value,
+                    ));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Length(
+                        self,
+                        self::fields::LengthField::Unit,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for LengthPercentage {
-    #[doc = "Calls [VisitMut`::visit_mut_length_percentage`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_length_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LengthPercentage {
+    #[doc = "Calls [VisitAstPath`::visit_length_percentage`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_length_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             LengthPercentage::Length { 0: _field_0 } => {
-                <Length as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LengthPercentage(
+                    self,
+                    self::fields::LengthPercentageField::Length,
+                ));
+                <Length as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             LengthPercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LengthPercentage(
+                    self,
+                    self::fields::LengthPercentageField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
-}
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ListOfComponentValues {
-    #[doc = "Calls [VisitMut`::visit_mut_list_of_component_values`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_list_of_component_values(visitor, self)
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ListOfComponentValues {
+    #[doc = "Calls [VisitAstPath`::visit_list_of_component_values`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_list_of_component_values(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ListOfComponentValues { span, children } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ListOfComponentValues(
+                            self,
+                            self::fields::ListOfComponentValuesField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(children, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ListOfComponentValues(
+                            self,
+                            self::fields::ListOfComponentValuesField::Children(usize::MAX),
+                        ));
+                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaAnd {
-    #[doc = "Calls [VisitMut`::visit_mut_media_and`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaAnd {
+    #[doc = "Calls [VisitAstPath`::visit_media_and`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_and(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaAnd {
                 span,
@@ -49234,208 +31024,534 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaAnd {
                 condition,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaAnd(
+                        self,
+                        self::fields::MediaAndField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaAnd(
+                        self,
+                        self::fields::MediaAndField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaInParens as VisitMutWith<V>>::visit_mut_with(condition, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaAnd(
+                        self,
+                        self::fields::MediaAndField::Condition,
+                    ));
+                    <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaCondition {
-    #[doc = "Calls [VisitMut`::visit_mut_media_condition`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaCondition {
+    #[doc = "Calls [VisitAstPath`::visit_media_condition`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaCondition { span, conditions } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaCondition(
+                        self,
+                        self::fields::MediaConditionField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<MediaConditionAllType> as VisitMutWith<V>>::visit_mut_with(
-                        conditions, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaCondition(
+                        self,
+                        self::fields::MediaConditionField::Conditions(usize::MAX),
+                    ));
+                    <Vec<MediaConditionAllType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionAllType {
-    #[doc = "Calls [VisitMut`::visit_mut_media_condition_all_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_condition_all_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionAllType {
+    #[doc = "Calls [VisitAstPath`::visit_media_condition_all_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_all_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaConditionAllType::Not { 0: _field_0 } => {
-                <MediaNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
+                        self,
+                        self::fields::MediaConditionAllTypeField::Not,
+                    ));
+                <MediaNot as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionAllType::And { 0: _field_0 } => {
-                <MediaAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
+                        self,
+                        self::fields::MediaConditionAllTypeField::And,
+                    ));
+                <MediaAnd as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionAllType::Or { 0: _field_0 } => {
-                <MediaOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
+                        self,
+                        self::fields::MediaConditionAllTypeField::Or,
+                    ));
+                <MediaOr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionAllType::MediaInParens { 0: _field_0 } => {
-                <MediaInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::MediaConditionAllType(
+                        self,
+                        self::fields::MediaConditionAllTypeField::MediaInParens,
+                    ));
+                <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionType {
-    #[doc = "Calls [VisitMut`::visit_mut_media_condition_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_condition_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionType {
+    #[doc = "Calls [VisitAstPath`::visit_media_condition_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaConditionType::All { 0: _field_0 } => {
-                <MediaCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaConditionType(
+                    self,
+                    self::fields::MediaConditionTypeField::All,
+                ));
+                <MediaCondition as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionType::WithoutOr { 0: _field_0 } => {
-                <MediaConditionWithoutOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaConditionType(
+                    self,
+                    self::fields::MediaConditionTypeField::WithoutOr,
+                ));
+                <MediaConditionWithoutOr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionWithoutOr {
-    #[doc = "Calls [VisitMut`::visit_mut_media_condition_without_or`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_condition_without_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionWithoutOr {
+    #[doc = "Calls [VisitAstPath`::visit_media_condition_without_or`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaConditionWithoutOr { span, conditions } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOr(
+                            self,
+                            self::fields::MediaConditionWithoutOrField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<MediaConditionWithoutOrType> as VisitMutWith<V>>::visit_mut_with(
-                        conditions, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOr(
+                            self,
+                            self::fields::MediaConditionWithoutOrField::Conditions(usize::MAX),
+                        ));
+                    <Vec<MediaConditionWithoutOrType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionWithoutOrType {
-    #[doc = "Calls [VisitMut`::visit_mut_media_condition_without_or_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_condition_without_or_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaConditionWithoutOrType {
+    #[doc = "Calls [VisitAstPath`::visit_media_condition_without_or_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaConditionWithoutOrType::Not { 0: _field_0 } => {
-                <MediaNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOrType(
+                        self,
+                        self::fields::MediaConditionWithoutOrTypeField::Not,
+                    ));
+                <MediaNot as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionWithoutOrType::And { 0: _field_0 } => {
-                <MediaAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOrType(
+                        self,
+                        self::fields::MediaConditionWithoutOrTypeField::And,
+                    ));
+                <MediaAnd as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionWithoutOrType::MediaInParens { 0: _field_0 } => {
-                <MediaInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::MediaConditionWithoutOrType(
+                        self,
+                        self::fields::MediaConditionWithoutOrTypeField::MediaInParens,
+                    ));
+                <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeature {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeature {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeature::Plain { 0: _field_0 } => {
-                <MediaFeaturePlain as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
+                    self,
+                    self::fields::MediaFeatureField::Plain,
+                ));
+                <MediaFeaturePlain as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeature::Boolean { 0: _field_0 } => {
-                <MediaFeatureBoolean as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
+                    self,
+                    self::fields::MediaFeatureField::Boolean,
+                ));
+                <MediaFeatureBoolean as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeature::Range { 0: _field_0 } => {
-                <MediaFeatureRange as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
+                    self,
+                    self::fields::MediaFeatureField::Range,
+                ));
+                <MediaFeatureRange as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeature::RangeInterval { 0: _field_0 } => {
-                <MediaFeatureRangeInterval as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeature(
+                    self,
+                    self::fields::MediaFeatureField::RangeInterval,
+                ));
+                <MediaFeatureRangeInterval as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureBoolean {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature_boolean`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature_boolean(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureBoolean {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature_boolean`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_boolean(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeatureBoolean { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureBoolean(
+                            self,
+                            self::fields::MediaFeatureBooleanField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureBoolean(
+                            self,
+                            self::fields::MediaFeatureBooleanField::Name,
+                        ));
+                    <MediaFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureName {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureName {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeatureName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureName(
+                    self,
+                    self::fields::MediaFeatureNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureName::ExtensionName { 0: _field_0 } => {
-                <ExtensionName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureName(
+                    self,
+                    self::fields::MediaFeatureNameField::ExtensionName,
+                ));
+                <ExtensionName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeaturePlain {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature_plain`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature_plain(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeaturePlain {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature_plain`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_plain(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeaturePlain { span, name, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeaturePlain(
+                            self,
+                            self::fields::MediaFeaturePlainField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeaturePlain(
+                            self,
+                            self::fields::MediaFeaturePlainField::Name,
+                        ));
+                    <MediaFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeaturePlain(
+                            self,
+                            self::fields::MediaFeaturePlainField::Value,
+                        ));
+                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRange {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature_range`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRange {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature_range`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeatureRange {
                 span,
@@ -49444,30 +31560,74 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRange {
                 right,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
+                            self,
+                            self::fields::MediaFeatureRangeField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
+                            self,
+                            self::fields::MediaFeatureRangeField::Left,
+                        ));
+                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
-                        comparison, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
+                            self,
+                            self::fields::MediaFeatureRangeField::Comparison,
+                        ));
+                    <MediaFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
+                        comparison,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRange(
+                            self,
+                            self::fields::MediaFeatureRangeField::Right,
+                        ));
+                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRangeComparison {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature_range_comparison`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature_range_comparison(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRangeComparison {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature_range_comparison`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range_comparison(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeatureRangeComparison::Lt => {}
             MediaFeatureRangeComparison::Le => {}
@@ -49477,13 +31637,23 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRangeComparison {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRangeInterval {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature_range_interval`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature_range_interval(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureRangeInterval {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature_range_interval`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_range_interval(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeatureRangeInterval {
                 span,
@@ -49494,86 +31664,228 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRangeInterval {
                 right,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
+                            self,
+                            self::fields::MediaFeatureRangeIntervalField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
+                            self,
+                            self::fields::MediaFeatureRangeIntervalField::Left,
+                        ));
+                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
+                            self,
+                            self::fields::MediaFeatureRangeIntervalField::LeftComparison,
+                        ));
+                    <MediaFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
                         left_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <MediaFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
+                            self,
+                            self::fields::MediaFeatureRangeIntervalField::Name,
+                        ));
+                    <MediaFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
+                            self,
+                            self::fields::MediaFeatureRangeIntervalField::RightComparison,
+                        ));
+                    <MediaFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
                         right_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::MediaFeatureRangeInterval(
+                            self,
+                            self::fields::MediaFeatureRangeIntervalField::Right,
+                        ));
+                    <Box<MediaFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureValue {
-    #[doc = "Calls [VisitMut`::visit_mut_media_feature_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_feature_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaFeatureValue {
+    #[doc = "Calls [VisitAstPath`::visit_media_feature_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_feature_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaFeatureValue::Number { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
+                    self,
+                    self::fields::MediaFeatureValueField::Number,
+                ));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
+                    self,
+                    self::fields::MediaFeatureValueField::Dimension,
+                ));
+                <Dimension as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
+                    self,
+                    self::fields::MediaFeatureValueField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Ratio { 0: _field_0 } => {
-                <Ratio as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
+                    self,
+                    self::fields::MediaFeatureValueField::Ratio,
+                ));
+                <Ratio as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaFeatureValue(
+                    self,
+                    self::fields::MediaFeatureValueField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaInParens {
-    #[doc = "Calls [VisitMut`::visit_mut_media_in_parens`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaInParens {
+    #[doc = "Calls [VisitAstPath`::visit_media_in_parens`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_in_parens(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaInParens::MediaCondition { 0: _field_0 } => {
-                <MediaCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaInParens(
+                    self,
+                    self::fields::MediaInParensField::MediaCondition,
+                ));
+                <MediaCondition as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaInParens::Feature { 0: _field_0 } => {
-                <Box<MediaFeature> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaInParens(
+                    self,
+                    self::fields::MediaInParensField::Feature,
+                ));
+                <Box<MediaFeature> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaInParens(
+                    self,
+                    self::fields::MediaInParensField::GeneralEnclosed,
+                ));
+                <GeneralEnclosed as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaNot {
-    #[doc = "Calls [VisitMut`::visit_mut_media_not`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaNot {
+    #[doc = "Calls [VisitAstPath`::visit_media_not`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_not(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaNot {
                 span,
@@ -49581,25 +31893,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaNot {
                 condition,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaNot(
+                        self,
+                        self::fields::MediaNotField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaNot(
+                        self,
+                        self::fields::MediaNotField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaInParens as VisitMutWith<V>>::visit_mut_with(condition, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaNot(
+                        self,
+                        self::fields::MediaNotField::Condition,
+                    ));
+                    <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaOr {
-    #[doc = "Calls [VisitMut`::visit_mut_media_or`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaOr {
+    #[doc = "Calls [VisitAstPath`::visit_media_or`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_or(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaOr {
                 span,
@@ -49607,25 +31953,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaOr {
                 condition,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaOr(
+                        self,
+                        self::fields::MediaOrField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaOr(
+                        self,
+                        self::fields::MediaOrField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MediaInParens as VisitMutWith<V>>::visit_mut_with(condition, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaOr(
+                        self,
+                        self::fields::MediaOrField::Condition,
+                    ));
+                    <MediaInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaQuery {
-    #[doc = "Calls [VisitMut`::visit_mut_media_query`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaQuery {
+    #[doc = "Calls [VisitAstPath`::visit_media_query`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_query(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaQuery {
                 span,
@@ -49635,208 +32015,492 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaQuery {
                 condition,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
+                        self,
+                        self::fields::MediaQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(modifier, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
+                        self,
+                        self::fields::MediaQueryField::Modifier,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        modifier,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<MediaType> as VisitMutWith<V>>::visit_mut_with(media_type, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
+                        self,
+                        self::fields::MediaQueryField::MediaType,
+                    ));
+                    <Option<MediaType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        media_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
+                        self,
+                        self::fields::MediaQueryField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<MediaConditionType>> as VisitMutWith<V>>::visit_mut_with(
-                        condition, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQuery(
+                        self,
+                        self::fields::MediaQueryField::Condition,
+                    ));
+                    <Option<Box<MediaConditionType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaQueryList {
-    #[doc = "Calls [VisitMut`::visit_mut_media_query_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_query_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaQueryList {
+    #[doc = "Calls [VisitAstPath`::visit_media_query_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_query_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaQueryList { span, queries } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQueryList(
+                        self,
+                        self::fields::MediaQueryListField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<MediaQuery> as VisitMutWith<V>>::visit_mut_with(queries, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaQueryList(
+                        self,
+                        self::fields::MediaQueryListField::Queries(usize::MAX),
+                    ));
+                    <Vec<MediaQuery> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        queries,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaType {
-    #[doc = "Calls [VisitMut`::visit_mut_media_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MediaType {
+    #[doc = "Calls [VisitAstPath`::visit_media_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MediaType::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MediaType(
+                    self,
+                    self::fields::MediaTypeField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamedNamespace {
-    #[doc = "Calls [VisitMut`::visit_mut_named_namespace`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_named_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamedNamespace {
+    #[doc = "Calls [VisitAstPath`::visit_named_namespace`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_named_namespace(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NamedNamespace { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedNamespace(
+                        self,
+                        self::fields::NamedNamespaceField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedNamespace(
+                        self,
+                        self::fields::NamedNamespaceField::Name,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Namespace {
-    #[doc = "Calls [VisitMut`::visit_mut_namespace`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Namespace {
+    #[doc = "Calls [VisitAstPath`::visit_namespace`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Namespace::Named { 0: _field_0 } => {
-                <NamedNamespace as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Namespace(
+                    self,
+                    self::fields::NamespaceField::Named,
+                ));
+                <NamedNamespace as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Namespace::Any { 0: _field_0 } => {
-                <AnyNamespace as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Namespace(
+                    self,
+                    self::fields::NamespaceField::Any,
+                ));
+                <AnyNamespace as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamespacePrefix {
-    #[doc = "Calls [VisitMut`::visit_mut_namespace_prefix`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_namespace_prefix(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamespacePrefix {
+    #[doc = "Calls [VisitAstPath`::visit_namespace_prefix`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prefix(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NamespacePrefix { span, namespace } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrefix(
+                        self,
+                        self::fields::NamespacePrefixField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Namespace> as VisitMutWith<V>>::visit_mut_with(namespace, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrefix(
+                        self,
+                        self::fields::NamespacePrefixField::Namespace,
+                    ));
+                    <Option<Namespace> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        namespace,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamespacePrelude {
-    #[doc = "Calls [VisitMut`::visit_mut_namespace_prelude`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_namespace_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamespacePrelude {
+    #[doc = "Calls [VisitAstPath`::visit_namespace_prelude`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NamespacePrelude { span, prefix, uri } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrelude(
+                        self,
+                        self::fields::NamespacePreludeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(prefix, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrelude(
+                        self,
+                        self::fields::NamespacePreludeField::Prefix,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<NamespacePreludeUri> as VisitMutWith<V>>::visit_mut_with(uri, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePrelude(
+                        self,
+                        self::fields::NamespacePreludeField::Uri,
+                    ));
+                    <Box<NamespacePreludeUri> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        uri,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamespacePreludeUri {
-    #[doc = "Calls [VisitMut`::visit_mut_namespace_prelude_uri`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_namespace_prelude_uri(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamespacePreludeUri {
+    #[doc = "Calls [VisitAstPath`::visit_namespace_prelude_uri`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_namespace_prelude_uri(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NamespacePreludeUri::Url { 0: _field_0 } => {
-                <Url as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePreludeUri(
+                    self,
+                    self::fields::NamespacePreludeUriField::Url,
+                ));
+                <Url as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             NamespacePreludeUri::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamespacePreludeUri(
+                    self,
+                    self::fields::NamespacePreludeUriField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NestingSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_nesting_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_nesting_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NestingSelector {
+    #[doc = "Calls [VisitAstPath`::visit_nesting_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_nesting_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NestingSelector { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NestingSelector(
+                        self,
+                        self::fields::NestingSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Number {
-    #[doc = "Calls [VisitMut`::visit_mut_number`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_number(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Number {
+    #[doc = "Calls [VisitAstPath`::visit_number`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_number(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Number { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
+                        self,
+                        self::fields::NumberField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
+                        self,
+                        self::fields::NumberField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NumberType {
-    #[doc = "Calls [VisitMut`::visit_mut_number_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_number_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NumberType {
+    #[doc = "Calls [VisitAstPath`::visit_number_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_number_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NumberType::Integer => {}
             NumberType::Number => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_page_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_page_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelector {
+    #[doc = "Calls [VisitAstPath`::visit_page_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PageSelector {
                 span,
@@ -49844,105 +32508,241 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelector {
                 pseudos,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelector(
+                        self,
+                        self::fields::PageSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<PageSelectorType> as VisitMutWith<V>>::visit_mut_with(
-                        page_type, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelector(
+                        self,
+                        self::fields::PageSelectorField::PageType,
+                    ));
+                    <Option<PageSelectorType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        page_type,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<Vec<PageSelectorPseudo>> as VisitMutWith<V>>::visit_mut_with(
-                        pseudos, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelector(
+                        self,
+                        self::fields::PageSelectorField::Pseudos(usize::MAX),
+                    ));
+                    <Option<Vec<PageSelectorPseudo>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        pseudos,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelectorList {
-    #[doc = "Calls [VisitMut`::visit_mut_page_selector_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_page_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelectorList {
+    #[doc = "Calls [VisitAstPath`::visit_page_selector_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PageSelectorList { span, selectors } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorList(
+                        self,
+                        self::fields::PageSelectorListField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<PageSelector> as VisitMutWith<V>>::visit_mut_with(selectors, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorList(
+                        self,
+                        self::fields::PageSelectorListField::Selectors(usize::MAX),
+                    ));
+                    <Vec<PageSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        selectors,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelectorPseudo {
-    #[doc = "Calls [VisitMut`::visit_mut_page_selector_pseudo`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_page_selector_pseudo(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelectorPseudo {
+    #[doc = "Calls [VisitAstPath`::visit_page_selector_pseudo`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_pseudo(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PageSelectorPseudo { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PageSelectorPseudo(
+                            self,
+                            self::fields::PageSelectorPseudoField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PageSelectorPseudo(
+                            self,
+                            self::fields::PageSelectorPseudoField::Value,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelectorType {
-    #[doc = "Calls [VisitMut`::visit_mut_page_selector_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_page_selector_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PageSelectorType {
+    #[doc = "Calls [VisitAstPath`::visit_page_selector_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PageSelectorType { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorType(
+                        self,
+                        self::fields::PageSelectorTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PageSelectorType(
+                        self,
+                        self::fields::PageSelectorTypeField::Value,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Percentage {
-    #[doc = "Calls [VisitMut`::visit_mut_percentage`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Percentage {
+    #[doc = "Calls [VisitAstPath`::visit_percentage`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Percentage { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Percentage(
+                        self,
+                        self::fields::PercentageField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Percentage(
+                        self,
+                        self::fields::PercentageField::Value,
+                    ));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoClassSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_pseudo_class_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoClassSelector {
+    #[doc = "Calls [VisitAstPath`::visit_pseudo_class_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PseudoClassSelector {
                 span,
@@ -49950,76 +32750,223 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoClassSelector {
                 children,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PseudoClassSelector(
+                            self,
+                            self::fields::PseudoClassSelectorField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PseudoClassSelector(
+                            self,
+                            self::fields::PseudoClassSelectorField::Name,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Vec<PseudoClassSelectorChildren>> as VisitMutWith<V>>::visit_mut_with(
-                        children, visitor,
-                    )
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PseudoClassSelector(
+                            self,
+                            self::fields::PseudoClassSelectorField::Children(usize::MAX),
+                        ));
+                    < Option < Vec < PseudoClassSelectorChildren > > as VisitWithAstPath < V > > :: visit_with_ast_path (children , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoClassSelectorChildren {
-    #[doc = "Calls [VisitMut`::visit_mut_pseudo_class_selector_children`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoClassSelectorChildren {
+    #[doc = "Calls [VisitAstPath`::visit_pseudo_class_selector_children`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector_children(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PseudoClassSelectorChildren::PreservedToken { 0: _field_0 } => {
-                <TokenAndSpan as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::PreservedToken,
+                    ));
+                <TokenAndSpan as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::AnPlusB { 0: _field_0 } => {
-                <AnPlusB as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::AnPlusB,
+                    ));
+                <AnPlusB as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::Ident,
+                    ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::Str,
+                    ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
-                <Delimiter as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::Delimiter,
+                    ));
+                <Delimiter as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
-                <ComplexSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::ComplexSelector,
+                    ));
+                <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::SelectorList { 0: _field_0 } => {
-                <SelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::SelectorList,
+                    ));
+                <SelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 } => {
-                <ForgivingSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::ForgivingSelectorList,
+                    ));
+                <ForgivingSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 } => {
-                <CompoundSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::CompoundSelectorList,
+                    ));
+                <CompoundSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 } => {
-                <RelativeSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::RelativeSelectorList,
+                    ));
+                <RelativeSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 } => {
-                <ForgivingRelativeSelectorList as VisitMutWith<V>>::visit_mut_with(
-                    _field_0, visitor,
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                    self,
+                    self::fields::PseudoClassSelectorChildrenField::ForgivingRelativeSelectorList,
+                ));
+                <ForgivingRelativeSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
                 );
             }
             PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoClassSelectorChildren(
+                        self,
+                        self::fields::PseudoClassSelectorChildrenField::CompoundSelector,
+                    ));
+                <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoElementSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_pseudo_element_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoElementSelector {
+    #[doc = "Calls [VisitAstPath`::visit_pseudo_element_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_element_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PseudoElementSelector {
                 span,
@@ -50027,50 +32974,127 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoElementSelector {
                 children,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PseudoElementSelector(
+                            self,
+                            self::fields::PseudoElementSelectorField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PseudoElementSelector(
+                            self,
+                            self::fields::PseudoElementSelectorField::Name,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Vec<PseudoElementSelectorChildren>> as VisitMutWith<V>>::visit_mut_with(
-                        children, visitor,
-                    )
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::PseudoElementSelector(
+                            self,
+                            self::fields::PseudoElementSelectorField::Children(usize::MAX),
+                        ));
+                    < Option < Vec < PseudoElementSelectorChildren > > as VisitWithAstPath < V > > :: visit_with_ast_path (children , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoElementSelectorChildren {
-    #[doc = "Calls [VisitMut`::visit_mut_pseudo_element_selector_children`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PseudoElementSelectorChildren {
+    #[doc = "Calls [VisitAstPath`::visit_pseudo_element_selector_children`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_element_selector_children(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PseudoElementSelectorChildren::PreservedToken { 0: _field_0 } => {
-                <TokenAndSpan as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
+                        self,
+                        self::fields::PseudoElementSelectorChildrenField::PreservedToken,
+                    ));
+                <TokenAndSpan as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
+                        self,
+                        self::fields::PseudoElementSelectorChildrenField::Ident,
+                    ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
+                        self,
+                        self::fields::PseudoElementSelectorChildrenField::CompoundSelector,
+                    ));
+                <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 } => {
-                <CustomHighlightName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::PseudoElementSelectorChildren(
+                        self,
+                        self::fields::PseudoElementSelectorChildrenField::CustomHighlightName,
+                    ));
+                <CustomHighlightName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for QualifiedRule {
-    #[doc = "Calls [VisitMut`::visit_mut_qualified_rule`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_qualified_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for QualifiedRule {
+    #[doc = "Calls [VisitAstPath`::visit_qualified_rule`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_qualified_rule(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             QualifiedRule {
                 span,
@@ -50078,87 +33102,223 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for QualifiedRule {
                 block,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRule(
+                        self,
+                        self::fields::QualifiedRuleField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <QualifiedRulePrelude as VisitMutWith<V>>::visit_mut_with(prelude, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRule(
+                        self,
+                        self::fields::QualifiedRuleField::Prelude,
+                    ));
+                    <QualifiedRulePrelude as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SimpleBlock as VisitMutWith<V>>::visit_mut_with(block, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRule(
+                        self,
+                        self::fields::QualifiedRuleField::Block,
+                    ));
+                    <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for QualifiedRulePrelude {
-    #[doc = "Calls [VisitMut`::visit_mut_qualified_rule_prelude`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_qualified_rule_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for QualifiedRulePrelude {
+    #[doc = "Calls [VisitAstPath`::visit_qualified_rule_prelude`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_qualified_rule_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             QualifiedRulePrelude::SelectorList { 0: _field_0 } => {
-                <SelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRulePrelude(
+                    self,
+                    self::fields::QualifiedRulePreludeField::SelectorList,
+                ));
+                <SelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 } => {
-                <RelativeSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRulePrelude(
+                    self,
+                    self::fields::QualifiedRulePreludeField::RelativeSelectorList,
+                ));
+                <RelativeSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QualifiedRulePrelude(
+                    self,
+                    self::fields::QualifiedRulePreludeField::ListOfComponentValues,
+                ));
+                <ListOfComponentValues as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for QueryInParens {
-    #[doc = "Calls [VisitMut`::visit_mut_query_in_parens`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_query_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for QueryInParens {
+    #[doc = "Calls [VisitAstPath`::visit_query_in_parens`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_query_in_parens(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             QueryInParens::ContainerQuery { 0: _field_0 } => {
-                <Box<ContainerQuery> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QueryInParens(
+                    self,
+                    self::fields::QueryInParensField::ContainerQuery,
+                ));
+                <Box<ContainerQuery> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QueryInParens::SizeFeature { 0: _field_0 } => {
-                <SizeFeature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QueryInParens(
+                    self,
+                    self::fields::QueryInParensField::SizeFeature,
+                ));
+                <SizeFeature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QueryInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::QueryInParens(
+                    self,
+                    self::fields::QueryInParensField::GeneralEnclosed,
+                ));
+                <GeneralEnclosed as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Ratio {
-    #[doc = "Calls [VisitMut`::visit_mut_ratio`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ratio(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Ratio {
+    #[doc = "Calls [VisitAstPath`::visit_ratio`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ratio(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Ratio { span, left, right } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ratio(
+                        self,
+                        self::fields::RatioField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ratio(
+                        self,
+                        self::fields::RatioField::Left,
+                    ));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Number> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ratio(
+                        self,
+                        self::fields::RatioField::Right,
+                    ));
+                    <Option<Number> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for RelativeSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_relative_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_relative_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RelativeSelector {
+    #[doc = "Calls [VisitAstPath`::visit_relative_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             RelativeSelector {
                 span,
@@ -50166,86 +33326,216 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for RelativeSelector {
                 selector,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RelativeSelector(
+                        self,
+                        self::fields::RelativeSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Combinator> as VisitMutWith<V>>::visit_mut_with(combinator, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RelativeSelector(
+                        self,
+                        self::fields::RelativeSelectorField::Combinator,
+                    ));
+                    <Option<Combinator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        combinator,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ComplexSelector as VisitMutWith<V>>::visit_mut_with(selector, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RelativeSelector(
+                        self,
+                        self::fields::RelativeSelectorField::Selector,
+                    ));
+                    <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                        selector,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for RelativeSelectorList {
-    #[doc = "Calls [VisitMut`::visit_mut_relative_selector_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_relative_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RelativeSelectorList {
+    #[doc = "Calls [VisitAstPath`::visit_relative_selector_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             RelativeSelectorList { span, children } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::RelativeSelectorList(
+                            self,
+                            self::fields::RelativeSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<RelativeSelector> as VisitMutWith<V>>::visit_mut_with(children, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::RelativeSelectorList(
+                            self,
+                            self::fields::RelativeSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<RelativeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Resolution {
-    #[doc = "Calls [VisitMut`::visit_mut_resolution`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_resolution(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Resolution {
+    #[doc = "Calls [VisitAstPath`::visit_resolution`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_resolution(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Resolution { span, value, unit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Resolution(
+                        self,
+                        self::fields::ResolutionField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Resolution(
+                        self,
+                        self::fields::ResolutionField::Value,
+                    ));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Resolution(
+                        self,
+                        self::fields::ResolutionField::Unit,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Rule {
-    #[doc = "Calls [VisitMut`::visit_mut_rule`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Rule {
+    #[doc = "Calls [VisitAstPath`::visit_rule`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_rule(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Rule::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Rule(
+                    self,
+                    self::fields::RuleField::QualifiedRule,
+                ));
+                <Box<QualifiedRule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Rule::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Rule(
+                    self,
+                    self::fields::RuleField::AtRule,
+                ));
+                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Rule::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Rule(
+                    self,
+                    self::fields::RuleField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ScopeRange {
-    #[doc = "Calls [VisitMut`::visit_mut_scope_range`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_scope_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ScopeRange {
+    #[doc = "Calls [VisitAstPath`::visit_scope_range`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_scope_range(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ScopeRange {
                 span,
@@ -50253,168 +33543,407 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ScopeRange {
                 scope_end,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ScopeRange(
+                        self,
+                        self::fields::ScopeRangeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<ForgivingSelectorList> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ScopeRange(
+                        self,
+                        self::fields::ScopeRangeField::ScopeStart,
+                    ));
+                    <Option<ForgivingSelectorList> as VisitWithAstPath<V>>::visit_with_ast_path(
                         scope_start,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<ForgivingSelectorList> as VisitMutWith<V>>::visit_mut_with(
-                        scope_end, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ScopeRange(
+                        self,
+                        self::fields::ScopeRangeField::ScopeEnd,
+                    ));
+                    <Option<ForgivingSelectorList> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        scope_end,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SelectorList {
-    #[doc = "Calls [VisitMut`::visit_mut_selector_list`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SelectorList {
+    #[doc = "Calls [VisitAstPath`::visit_selector_list`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SelectorList { span, children } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SelectorList(
+                        self,
+                        self::fields::SelectorListField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ComplexSelector> as VisitMutWith<V>>::visit_mut_with(children, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SelectorList(
+                        self,
+                        self::fields::SelectorListField::Children(usize::MAX),
+                    ));
+                    <Vec<ComplexSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SequenceOfCustomIdents {
-    #[doc = "Calls [VisitMut`::visit_mut_sequence_of_custom_idents`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_sequence_of_custom_idents(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SequenceOfCustomIdents {
+    #[doc = "Calls [VisitAstPath`::visit_sequence_of_custom_idents`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_sequence_of_custom_idents(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SequenceOfCustomIdents { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SequenceOfCustomIdents(
+                            self,
+                            self::fields::SequenceOfCustomIdentsField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<CustomIdent> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SequenceOfCustomIdents(
+                            self,
+                            self::fields::SequenceOfCustomIdentsField::Value(usize::MAX),
+                        ));
+                    <Vec<CustomIdent> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SimpleBlock {
-    #[doc = "Calls [VisitMut`::visit_mut_simple_block`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_simple_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SimpleBlock {
+    #[doc = "Calls [VisitAstPath`::visit_simple_block`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_simple_block(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SimpleBlock { span, name, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleBlock(
+                        self,
+                        self::fields::SimpleBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TokenAndSpan as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleBlock(
+                        self,
+                        self::fields::SimpleBlockField::Name,
+                    ));
+                    <TokenAndSpan as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleBlock(
+                        self,
+                        self::fields::SimpleBlockField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeature {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeature {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeature::Plain { 0: _field_0 } => {
-                <SizeFeaturePlain as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
+                    self,
+                    self::fields::SizeFeatureField::Plain,
+                ));
+                <SizeFeaturePlain as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeature::Boolean { 0: _field_0 } => {
-                <SizeFeatureBoolean as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
+                    self,
+                    self::fields::SizeFeatureField::Boolean,
+                ));
+                <SizeFeatureBoolean as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeature::Range { 0: _field_0 } => {
-                <SizeFeatureRange as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
+                    self,
+                    self::fields::SizeFeatureField::Range,
+                ));
+                <SizeFeatureRange as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeature::RangeInterval { 0: _field_0 } => {
-                <SizeFeatureRangeInterval as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeature(
+                    self,
+                    self::fields::SizeFeatureField::RangeInterval,
+                ));
+                <SizeFeatureRangeInterval as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureBoolean {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature_boolean`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature_boolean(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureBoolean {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature_boolean`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_boolean(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeatureBoolean { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureBoolean(
+                            self,
+                            self::fields::SizeFeatureBooleanField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SizeFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureBoolean(
+                            self,
+                            self::fields::SizeFeatureBooleanField::Name,
+                        ));
+                    <SizeFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureName {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureName {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeatureName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureName(
+                    self,
+                    self::fields::SizeFeatureNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeaturePlain {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature_plain`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature_plain(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeaturePlain {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature_plain`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_plain(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeaturePlain { span, name, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeaturePlain(
+                        self,
+                        self::fields::SizeFeaturePlainField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SizeFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeaturePlain(
+                        self,
+                        self::fields::SizeFeaturePlainField::Name,
+                    ));
+                    <SizeFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeaturePlain(
+                        self,
+                        self::fields::SizeFeaturePlainField::Value,
+                    ));
+                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRange {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature_range`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRange {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature_range`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeatureRange {
                 span,
@@ -50423,30 +33952,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRange {
                 right,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
+                        self,
+                        self::fields::SizeFeatureRangeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
+                        self,
+                        self::fields::SizeFeatureRangeField::Left,
+                    ));
+                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SizeFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
-                        comparison, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
+                        self,
+                        self::fields::SizeFeatureRangeField::Comparison,
+                    ));
+                    <SizeFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
+                        comparison,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureRange(
+                        self,
+                        self::fields::SizeFeatureRangeField::Right,
+                    ));
+                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRangeComparison {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature_range_comparison`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature_range_comparison(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRangeComparison {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature_range_comparison`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range_comparison(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeatureRangeComparison::Lt => {}
             SizeFeatureRangeComparison::Le => {}
@@ -50456,13 +34025,23 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRangeComparison {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRangeInterval {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature_range_interval`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature_range_interval(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureRangeInterval {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature_range_interval`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_range_interval(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeatureRangeInterval {
                 span,
@@ -50473,156 +34052,410 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRangeInterval {
                 right,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
+                            self,
+                            self::fields::SizeFeatureRangeIntervalField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
+                            self,
+                            self::fields::SizeFeatureRangeIntervalField::Left,
+                        ));
+                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SizeFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
+                            self,
+                            self::fields::SizeFeatureRangeIntervalField::LeftComparison,
+                        ));
+                    <SizeFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
                         left_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <SizeFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
+                            self,
+                            self::fields::SizeFeatureRangeIntervalField::Name,
+                        ));
+                    <SizeFeatureName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SizeFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
+                            self,
+                            self::fields::SizeFeatureRangeIntervalField::RightComparison,
+                        ));
+                    <SizeFeatureRangeComparison as VisitWithAstPath<V>>::visit_with_ast_path(
                         right_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SizeFeatureRangeInterval(
+                            self,
+                            self::fields::SizeFeatureRangeIntervalField::Right,
+                        ));
+                    <Box<SizeFeatureValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureValue {
-    #[doc = "Calls [VisitMut`::visit_mut_size_feature_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_size_feature_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SizeFeatureValue {
+    #[doc = "Calls [VisitAstPath`::visit_size_feature_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_size_feature_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SizeFeatureValue::Number { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
+                    self,
+                    self::fields::SizeFeatureValueField::Number,
+                ));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
+                    self,
+                    self::fields::SizeFeatureValueField::Dimension,
+                ));
+                <Dimension as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
+                    self,
+                    self::fields::SizeFeatureValueField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Ratio { 0: _field_0 } => {
-                <Ratio as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
+                    self,
+                    self::fields::SizeFeatureValueField::Ratio,
+                ));
+                <Ratio as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SizeFeatureValue(
+                    self,
+                    self::fields::SizeFeatureValueField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Str {
-    #[doc = "Calls [VisitMut`::visit_mut_str`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_str(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Str {
+    #[doc = "Calls [VisitAstPath`::visit_str`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_str(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Str { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Value));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Raw));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for StyleBlock {
-    #[doc = "Calls [VisitMut`::visit_mut_style_block`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_style_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for StyleBlock {
+    #[doc = "Calls [VisitAstPath`::visit_style_block`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_style_block(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             StyleBlock::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
+                    self,
+                    self::fields::StyleBlockField::AtRule,
+                ));
+                <Box<AtRule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             StyleBlock::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
+                    self,
+                    self::fields::StyleBlockField::Declaration,
+                ));
+                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             StyleBlock::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
+                    self,
+                    self::fields::StyleBlockField::QualifiedRule,
+                ));
+                <Box<QualifiedRule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             StyleBlock::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StyleBlock(
+                    self,
+                    self::fields::StyleBlockField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Stylesheet {
-    #[doc = "Calls [VisitMut`::visit_mut_stylesheet`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_stylesheet(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Stylesheet {
+    #[doc = "Calls [VisitAstPath`::visit_stylesheet`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_stylesheet(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Stylesheet { span, rules } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stylesheet(
+                        self,
+                        self::fields::StylesheetField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Rule> as VisitMutWith<V>>::visit_mut_with(rules, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stylesheet(
+                        self,
+                        self::fields::StylesheetField::Rules(usize::MAX),
+                    ));
+                    <Vec<Rule> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        rules,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SubclassSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_subclass_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_subclass_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SubclassSelector {
+    #[doc = "Calls [VisitAstPath`::visit_subclass_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_subclass_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SubclassSelector::Id { 0: _field_0 } => {
-                <IdSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
+                    self,
+                    self::fields::SubclassSelectorField::Id,
+                ));
+                <IdSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::Class { 0: _field_0 } => {
-                <ClassSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
+                    self,
+                    self::fields::SubclassSelectorField::Class,
+                ));
+                <ClassSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::Attribute { 0: _field_0 } => {
-                <Box<AttributeSelector> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
+                    self,
+                    self::fields::SubclassSelectorField::Attribute,
+                ));
+                <Box<AttributeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::PseudoClass { 0: _field_0 } => {
-                <PseudoClassSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
+                    self,
+                    self::fields::SubclassSelectorField::PseudoClass,
+                ));
+                <PseudoClassSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::PseudoElement { 0: _field_0 } => {
-                <PseudoElementSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SubclassSelector(
+                    self,
+                    self::fields::SubclassSelectorField::PseudoElement,
+                ));
+                <PseudoElementSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsAnd {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_and`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsAnd {
+    #[doc = "Calls [VisitAstPath`::visit_supports_and`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_and(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SupportsAnd {
                 span,
@@ -50630,106 +34463,272 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsAnd {
                 condition,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsAnd(
+                        self,
+                        self::fields::SupportsAndField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsAnd(
+                        self,
+                        self::fields::SupportsAndField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<SupportsInParens> as VisitMutWith<V>>::visit_mut_with(condition, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsAnd(
+                        self,
+                        self::fields::SupportsAndField::Condition,
+                    ));
+                    <Box<SupportsInParens> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsCondition {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_condition`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsCondition {
+    #[doc = "Calls [VisitAstPath`::visit_supports_condition`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SupportsCondition { span, conditions } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SupportsCondition(
+                            self,
+                            self::fields::SupportsConditionField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<SupportsConditionType> as VisitMutWith<V>>::visit_mut_with(
-                        conditions, visitor,
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::SupportsCondition(
+                            self,
+                            self::fields::SupportsConditionField::Conditions(usize::MAX),
+                        ));
+                    <Vec<SupportsConditionType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsConditionType {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_condition_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_condition_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsConditionType {
+    #[doc = "Calls [VisitAstPath`::visit_supports_condition_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SupportsConditionType::Not { 0: _field_0 } => {
-                <SupportsNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
+                        self,
+                        self::fields::SupportsConditionTypeField::Not,
+                    ));
+                <SupportsNot as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsConditionType::And { 0: _field_0 } => {
-                <SupportsAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
+                        self,
+                        self::fields::SupportsConditionTypeField::And,
+                    ));
+                <SupportsAnd as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsConditionType::Or { 0: _field_0 } => {
-                <SupportsOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
+                        self,
+                        self::fields::SupportsConditionTypeField::Or,
+                    ));
+                <SupportsOr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsConditionType::SupportsInParens { 0: _field_0 } => {
-                <SupportsInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::SupportsConditionType(
+                        self,
+                        self::fields::SupportsConditionTypeField::SupportsInParens,
+                    ));
+                <SupportsInParens as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsFeature {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_feature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsFeature {
+    #[doc = "Calls [VisitAstPath`::visit_supports_feature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_feature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SupportsFeature::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsFeature(
+                    self,
+                    self::fields::SupportsFeatureField::Declaration,
+                ));
+                <Box<Declaration> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsFeature::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsFeature(
+                    self,
+                    self::fields::SupportsFeatureField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsInParens {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_in_parens`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsInParens {
+    #[doc = "Calls [VisitAstPath`::visit_supports_in_parens`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_in_parens(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SupportsInParens::SupportsCondition { 0: _field_0 } => {
-                <SupportsCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsInParens(
+                    self,
+                    self::fields::SupportsInParensField::SupportsCondition,
+                ));
+                <SupportsCondition as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsInParens::Feature { 0: _field_0 } => {
-                <SupportsFeature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsInParens(
+                    self,
+                    self::fields::SupportsInParensField::Feature,
+                ));
+                <SupportsFeature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsInParens(
+                    self,
+                    self::fields::SupportsInParensField::GeneralEnclosed,
+                ));
+                <GeneralEnclosed as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsNot {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_not`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsNot {
+    #[doc = "Calls [VisitAstPath`::visit_supports_not`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_not(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SupportsNot {
                 span,
@@ -50737,25 +34736,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsNot {
                 condition,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsNot(
+                        self,
+                        self::fields::SupportsNotField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsNot(
+                        self,
+                        self::fields::SupportsNotField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<SupportsInParens> as VisitMutWith<V>>::visit_mut_with(condition, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsNot(
+                        self,
+                        self::fields::SupportsNotField::Condition,
+                    ));
+                    <Box<SupportsInParens> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsOr {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_or`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SupportsOr {
+    #[doc = "Calls [VisitAstPath`::visit_supports_or`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_or(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SupportsOr {
                 span,
@@ -50763,166 +34796,459 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsOr {
                 condition,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsOr(
+                        self,
+                        self::fields::SupportsOrField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsOr(
+                        self,
+                        self::fields::SupportsOrField::Keyword,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<SupportsInParens> as VisitMutWith<V>>::visit_mut_with(condition, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SupportsOr(
+                        self,
+                        self::fields::SupportsOrField::Condition,
+                    ));
+                    <Box<SupportsInParens> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TagNameSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_tag_name_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_tag_name_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TagNameSelector {
+    #[doc = "Calls [VisitAstPath`::visit_tag_name_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tag_name_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TagNameSelector { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TagNameSelector(
+                        self,
+                        self::fields::TagNameSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <WqName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TagNameSelector(
+                        self,
+                        self::fields::TagNameSelectorField::Name,
+                    ));
+                    <WqName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Time {
-    #[doc = "Calls [VisitMut`::visit_mut_time`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_time(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Time {
+    #[doc = "Calls [VisitAstPath`::visit_time`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_time(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Time { span, value, unit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Time(self, self::fields::TimeField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Time(self, self::fields::TimeField::Value));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Time(self, self::fields::TimeField::Unit));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TimePercentage {
-    #[doc = "Calls [VisitMut`::visit_mut_time_percentage`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_time_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TimePercentage {
+    #[doc = "Calls [VisitAstPath`::visit_time_percentage`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_time_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TimePercentage::Time { 0: _field_0 } => {
-                <Time as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TimePercentage(
+                    self,
+                    self::fields::TimePercentageField::Time,
+                ));
+                <Time as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TimePercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TimePercentage(
+                    self,
+                    self::fields::TimePercentageField::Percentage,
+                ));
+                <Percentage as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Token {
-    #[doc = "Calls [VisitMut`::visit_mut_token`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_token(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Token {
+    #[doc = "Calls [VisitAstPath`::visit_token`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_token(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Token::Ident { value, raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::Ident,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::Function { value, raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::Function,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::AtKeyword { value, raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::AtKeyword,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::Hash { is_id, value, raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::Hash,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::String { value, raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::String,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::BadString { raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::BadString,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::Url { value, raw } => {
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Url));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<UrlKeyValue> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <Box<UrlKeyValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::BadUrl { raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::BadUrl,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
-            Token::Delim { value } => {}
+            Token::Delim { value } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::Delim,
+                ));
+            }
             Token::Number {
                 value,
                 raw,
                 type_flag,
             } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::Number,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <NumberType as VisitMutWith<V>>::visit_mut_with(type_flag, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::TypeFlag,
+                    ));
+                    <NumberType as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_flag,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::Percentage { value, raw } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::Percentage,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Token(self, self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::Dimension { 0: _field_0 } => {
-                <Box<DimensionToken> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::Dimension,
+                ));
+                <Box<DimensionToken> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Token::WhiteSpace { value } => {
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                    self,
+                    self::fields::TokenField::WhiteSpace,
+                ));
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Token(
+                        self,
+                        self::fields::TokenField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
             Token::CDO => {}
@@ -50939,49 +35265,111 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Token {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TokenAndSpan {
-    #[doc = "Calls [VisitMut`::visit_mut_token_and_span`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_token_and_span(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TokenAndSpan {
+    #[doc = "Calls [VisitAstPath`::visit_token_and_span`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_token_and_span(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TokenAndSpan { span, token } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TokenAndSpan(
+                        self,
+                        self::fields::TokenAndSpanField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Token as VisitMutWith<V>>::visit_mut_with(token, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TokenAndSpan(
+                        self,
+                        self::fields::TokenAndSpanField::Token,
+                    ));
+                    <Token as VisitWithAstPath<V>>::visit_with_ast_path(
+                        token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TypeSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_type_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_type_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TypeSelector {
+    #[doc = "Calls [VisitAstPath`::visit_type_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_type_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TypeSelector::TagName { 0: _field_0 } => {
-                <TagNameSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TypeSelector(
+                    self,
+                    self::fields::TypeSelectorField::TagName,
+                ));
+                <TagNameSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TypeSelector::Universal { 0: _field_0 } => {
-                <UniversalSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TypeSelector(
+                    self,
+                    self::fields::TypeSelectorField::Universal,
+                ));
+                <UniversalSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnicodeRange {
-    #[doc = "Calls [VisitMut`::visit_mut_unicode_range`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_unicode_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnicodeRange {
+    #[doc = "Calls [VisitAstPath`::visit_unicode_range`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unicode_range(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UnicodeRange {
                 span,
@@ -50990,69 +35378,173 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnicodeRange {
                 raw,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
+                        self,
+                        self::fields::UnicodeRangeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(start, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
+                        self,
+                        self::fields::UnicodeRangeField::Start,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        start,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(end, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
+                        self,
+                        self::fields::UnicodeRangeField::End,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        end,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnicodeRange(
+                        self,
+                        self::fields::UnicodeRangeField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UniversalSelector {
-    #[doc = "Calls [VisitMut`::visit_mut_universal_selector`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_universal_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UniversalSelector {
+    #[doc = "Calls [VisitAstPath`::visit_universal_selector`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_universal_selector(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UniversalSelector { span, prefix } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::UniversalSelector(
+                            self,
+                            self::fields::UniversalSelectorField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<NamespacePrefix> as VisitMutWith<V>>::visit_mut_with(prefix, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::UniversalSelector(
+                            self,
+                            self::fields::UniversalSelectorField::Prefix,
+                        ));
+                    <Option<NamespacePrefix> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnknownDimension {
-    #[doc = "Calls [VisitMut`::visit_mut_unknown_dimension`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_unknown_dimension(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnknownDimension {
+    #[doc = "Calls [VisitAstPath`::visit_unknown_dimension`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unknown_dimension(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UnknownDimension { span, value, unit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnknownDimension(
+                        self,
+                        self::fields::UnknownDimensionField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnknownDimension(
+                        self,
+                        self::fields::UnknownDimensionField::Value,
+                    ));
+                    <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnknownDimension(
+                        self,
+                        self::fields::UnknownDimensionField::Unit,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Url {
-    #[doc = "Calls [VisitMut`::visit_mut_url`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_url(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Url {
+    #[doc = "Calls [VisitAstPath`::visit_url`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Url {
                 span,
@@ -51061,104 +35553,242 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Url {
                 modifiers,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Url(self, self::fields::UrlField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Url(self, self::fields::UrlField::Name));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<UrlValue>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Url(self, self::fields::UrlField::Value));
+                    <Option<Box<UrlValue>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Vec<UrlModifier>> as VisitMutWith<V>>::visit_mut_with(
-                        modifiers, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Url(
+                        self,
+                        self::fields::UrlField::Modifiers(usize::MAX),
+                    ));
+                    <Option<Vec<UrlModifier>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        modifiers,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlKeyValue {
-    #[doc = "Calls [VisitMut`::visit_mut_url_key_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_url_key_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlKeyValue {
+    #[doc = "Calls [VisitAstPath`::visit_url_key_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_key_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UrlKeyValue {
                 0: _field_0,
                 1: _field_1,
             } => {
-                <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
-                <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(_field_1, visitor);
+                <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_1,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlModifier {
-    #[doc = "Calls [VisitMut`::visit_mut_url_modifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_url_modifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlModifier {
+    #[doc = "Calls [VisitAstPath`::visit_url_modifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_modifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UrlModifier::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlModifier(
+                    self,
+                    self::fields::UrlModifierField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             UrlModifier::Function { 0: _field_0 } => {
-                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlModifier(
+                    self,
+                    self::fields::UrlModifierField::Function,
+                ));
+                <Function as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlValue {
-    #[doc = "Calls [VisitMut`::visit_mut_url_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_url_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlValue {
+    #[doc = "Calls [VisitAstPath`::visit_url_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UrlValue::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValue(
+                    self,
+                    self::fields::UrlValueField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             UrlValue::Raw { 0: _field_0 } => {
-                <UrlValueRaw as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValue(
+                    self,
+                    self::fields::UrlValueField::Raw,
+                ));
+                <UrlValueRaw as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlValueRaw {
-    #[doc = "Calls [VisitMut`::visit_mut_url_value_raw`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_url_value_raw(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UrlValueRaw {
+    #[doc = "Calls [VisitAstPath`::visit_url_value_raw`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_value_raw(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UrlValueRaw { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValueRaw(
+                        self,
+                        self::fields::UrlValueRawField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValueRaw(
+                        self,
+                        self::fields::UrlValueRawField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UrlValueRaw(
+                        self,
+                        self::fields::UrlValueRawField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for WqName {
-    #[doc = "Calls [VisitMut`::visit_mut_wq_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_wq_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WqName {
+    #[doc = "Calls [VisitAstPath`::visit_wq_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_wq_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             WqName {
                 span,
@@ -51166,7301 +35796,5873 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for WqName {
                 value,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WqName(
+                        self,
+                        self::fields::WqNameField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<NamespacePrefix> as VisitMutWith<V>>::visit_mut_with(prefix, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WqName(
+                        self,
+                        self::fields::WqNameField::Prefix,
+                    ));
+                    <Option<NamespacePrefix> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WqName(
+                        self,
+                        self::fields::WqNameField::Value,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitMut`::visit_mut_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
+    #[doc = "Calls [VisitAstPath`::visit_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_atom(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         {}
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CalcProductOrOperator> {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_product_or_operators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcProductOrOperator] {
+    #[doc = "Calls [VisitAstPath`::visit_calc_product_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_product_or_operators(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_product_or_operators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <CalcProductOrOperator as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CalcProductOrOperator as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CalcValueOrOperator> {
-    #[doc = "Calls [VisitMut`::visit_mut_calc_value_or_operators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcValueOrOperator] {
+    #[doc = "Calls [VisitAstPath`::visit_calc_value_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_calc_value_or_operators(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_calc_value_or_operators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <CalcValueOrOperator as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CalcValueOrOperator as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComplexSelectorChildren> {
-    #[doc = "Calls [VisitMut`::visit_mut_complex_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelectorChildren] {
+    #[doc = "Calls [VisitAstPath`::visit_complex_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_complex_selector_childrens(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <ComplexSelectorChildren as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ComplexSelectorChildren as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComplexSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_complex_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_complex_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_complex_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ComplexSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComponentValue> {
-    #[doc = "Calls [VisitMut`::visit_mut_component_values`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComponentValue] {
+    #[doc = "Calls [VisitAstPath`::visit_component_values`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_component_values(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_component_values(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ComponentValue as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ComponentValue as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CompoundSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_compound_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CompoundSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_compound_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_compound_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_compound_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <CompoundSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CompoundSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ContainerQueryType> {
-    #[doc = "Calls [VisitMut`::visit_mut_container_query_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ContainerQueryType] {
+    #[doc = "Calls [VisitAstPath`::visit_container_query_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_container_query_types(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_container_query_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ContainerQueryType as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ContainerQueryType as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CustomIdent> {
-    #[doc = "Calls [VisitMut`::visit_mut_custom_idents`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CustomIdent] {
+    #[doc = "Calls [VisitAstPath`::visit_custom_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_custom_idents(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_custom_idents(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <CustomIdent as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CustomIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<DocumentPreludeMatchingFunction> {
-    #[doc = "Calls [VisitMut`::visit_mut_document_prelude_matching_functions`] with `self`. (Extra \
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [DocumentPreludeMatchingFunction] {
+    #[doc = "Calls [VisitAstPath`::visit_document_prelude_matching_functions`] with `self`. (Extra \
              impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_document_prelude_matching_functions(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_document_prelude_matching_functions(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <DocumentPreludeMatchingFunction as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <DocumentPreludeMatchingFunction as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<FamilyName> {
-    #[doc = "Calls [VisitMut`::visit_mut_family_names`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [FamilyName] {
+    #[doc = "Calls [VisitAstPath`::visit_family_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_family_names(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_family_names(visitor, self, __ast_path)
+    }
+
+    #[inline]
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <FamilyName as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
+    }
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingComplexSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_forgiving_complex_selectors`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_complex_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <FamilyName as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ForgivingComplexSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ForgivingComplexSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_forgiving_complex_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingRelativeSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_forgiving_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_forgiving_complex_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_forgiving_relative_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <ForgivingComplexSelector as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ForgivingRelativeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ForgivingRelativeSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_forgiving_relative_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Ident] {
+    #[doc = "Calls [VisitAstPath`::visit_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_forgiving_relative_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_idents(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <ForgivingRelativeSelector as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Ident as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Ident> {
-    #[doc = "Calls [VisitMut`::visit_mut_idents`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [KeyframeSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_keyframe_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_idents(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_keyframe_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Ident as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <KeyframeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<KeyframeSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_keyframe_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [LayerName] {
+    #[doc = "Calls [VisitAstPath`::visit_layer_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_keyframe_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_layer_names(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <KeyframeSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <LayerName as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<LayerName> {
-    #[doc = "Calls [VisitMut`::visit_mut_layer_names`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionAllType] {
+    #[doc = "Calls [VisitAstPath`::visit_media_condition_all_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_layer_names(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_all_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <LayerName as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <MediaConditionAllType as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaConditionAllType> {
-    #[doc = "Calls [VisitMut`::visit_mut_media_condition_all_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionWithoutOrType] {
+    #[doc = "Calls [VisitAstPath`::visit_media_condition_without_or_types`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_condition_all_types(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_condition_without_or_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <MediaConditionAllType as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <MediaConditionWithoutOrType as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaConditionWithoutOrType> {
-    #[doc = "Calls [VisitMut`::visit_mut_media_condition_without_or_types`] with `self`. (Extra \
-             impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaQuery] {
+    #[doc = "Calls [VisitAstPath`::visit_media_querys`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_condition_without_or_types(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_media_querys(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <MediaConditionWithoutOrType as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <MediaQuery as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaQuery> {
-    #[doc = "Calls [VisitMut`::visit_mut_media_querys`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<AtRulePrelude>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_at_rule_prelude`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_media_querys(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_at_rule_prelude(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <MediaQuery as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            Some(inner) => <Box<AtRulePrelude> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<AtRulePrelude>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_at_rule_prelude`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_at_rule_prelude(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<AtRulePrelude> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorMatcher> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_atom(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_matcher(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <AttributeSelectorMatcher as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorMatcher> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorModifier> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_attribute_selector_modifier`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_modifier(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <AttributeSelectorMatcher as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <AttributeSelectorModifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorModifier> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_attribute_selector_modifier`] with `self`. (Extra \
-             impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorValue> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_attribute_selector_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_attribute_selector_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <AttributeSelectorModifier as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <AttributeSelectorValue as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorValue> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_attribute_selector_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Combinator> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_combinator`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_attribute_selector_value(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_combinator(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Some(inner) => {
-                <AttributeSelectorValue as VisitMutWith<V>>::visit_mut_with(inner, visitor)
+                <Combinator as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
             }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Combinator> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_combinator`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ContainerName> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_container_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_combinator(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_container_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Combinator as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <ContainerName as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ContainerName> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_container_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ForgivingSelectorList> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_container_name(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_forgiving_selector_list(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <ContainerName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <ForgivingSelectorList as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ForgivingSelectorList> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Function>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_function`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_forgiving_selector_list(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_function(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <ForgivingSelectorList as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Function>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_function`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_function(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ident(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<Function> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Ident> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportConditions>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_import_conditions`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ident(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_import_conditions(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Ident as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Box<ImportConditions> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ImportConditions>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_import_conditions`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportLayerName>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_import_layer_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_import_conditions(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_import_layer_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <Box<ImportConditions> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <Box<ImportLayerName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ImportLayerName>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_import_layer_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ImportantFlag> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_important_flag`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_import_layer_name(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_important_flag(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <Box<ImportLayerName> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <ImportantFlag as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ImportantFlag> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_important_flag`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaConditionType>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_media_condition_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_important_flag(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_condition_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <ImportantFlag as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Box<MediaConditionType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<MediaConditionType>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_media_condition_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaQueryList>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_media_query_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_media_condition_type(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_query_list(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <Box<MediaConditionType> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <Box<MediaQueryList> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<MediaQueryList>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_media_query_list`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<MediaType> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_media_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_media_query_list(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_media_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<MediaQueryList> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <MediaType as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<MediaType> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_media_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_namespace`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_media_type(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_namespace(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <MediaType as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Namespace as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Namespace> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_namespace`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NamespacePrefix> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_namespace_prefix`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_namespace(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_namespace_prefix(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Namespace as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <NamespacePrefix as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<NamespacePrefix> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_namespace_prefix`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NestingSelector> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_nesting_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_namespace_prefix(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_nesting_selector(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <NamespacePrefix as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <NestingSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<NestingSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_nesting_selector`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Number> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_number`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_nesting_selector(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_number(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <NestingSelector as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Number> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_number`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PageSelectorPseudo>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_number(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_page_selector_pseudos(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Number as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Vec<PageSelectorPseudo> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PageSelectorPseudo>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<PageSelectorType> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_page_selector_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_page_selector_pseudos(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_page_selector_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <Vec<PageSelectorPseudo> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <PageSelectorType as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<PageSelectorType> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_page_selector_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoClassSelectorChildren>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_page_selector_type(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <PageSelectorType as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Vec<PseudoClassSelectorChildren> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
-             impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoElementSelectorChildren>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_pseudo_element_selector_childrens`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Vec<PseudoClassSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
-                inner, visitor,
-            ),
+            Some(inner) => {
+                <Vec<PseudoElementSelectorChildren> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_pseudo_element_selector_childrens`] with `self`. \
-             (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<SimpleBlock> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_simple_block`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_simple_block(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Vec<PseudoElementSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
-                inner, visitor,
+            Some(inner) => <SimpleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
             ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<SimpleBlock> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_simple_block`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TypeSelector>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_type_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_simple_block(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_type_selector(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <SimpleBlock as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Box<TypeSelector> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TypeSelector>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_type_selector`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<UrlModifier>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_type_selector(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_url_modifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<TypeSelector> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Vec<UrlModifier> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<UrlModifier>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_url_modifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<UrlValue>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_url_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_url_modifiers(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_url_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Vec<UrlModifier> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Box<UrlValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<UrlValue>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_url_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelectorPseudo] {
+    #[doc = "Calls [VisitAstPath`::visit_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_url_value(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selector_pseudos(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<UrlValue> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
-            None => {}
-        }
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PageSelectorPseudo as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PageSelectorPseudo> {
-    #[doc = "Calls [VisitMut`::visit_mut_page_selector_pseudos`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_page_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_page_selector_pseudos(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_page_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <PageSelectorPseudo as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PageSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PageSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_page_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoClassSelectorChildren] {
+    #[doc = "Calls [VisitAstPath`::visit_pseudo_class_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_page_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_class_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <PageSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PseudoClassSelectorChildren as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PseudoClassSelectorChildren> {
-    #[doc = "Calls [VisitMut`::visit_mut_pseudo_class_selector_childrens`] with `self`. (Extra \
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoElementSelectorChildren] {
+    #[doc = "Calls [VisitAstPath`::visit_pseudo_element_selector_childrens`] with `self`. (Extra \
              impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pseudo_element_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <PseudoClassSelectorChildren as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PseudoElementSelectorChildren as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PseudoElementSelectorChildren> {
-    #[doc = "Calls [VisitMut`::visit_mut_pseudo_element_selector_childrens`] with `self`. (Extra \
-             impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [RelativeSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_relative_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <PseudoElementSelectorChildren as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <RelativeSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<RelativeSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_relative_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Rule] {
+    #[doc = "Calls [VisitAstPath`::visit_rules`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_relative_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_rules(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <RelativeSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Rule as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Rule> {
-    #[doc = "Calls [VisitMut`::visit_mut_rules`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
+    #[doc = "Calls [VisitAstPath`::visit_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_rules(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Rule as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        {}
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_common::Span {
-    #[doc = "Calls [VisitMut`::visit_mut_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SubclassSelector] {
+    #[doc = "Calls [VisitAstPath`::visit_subclass_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_span(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_subclass_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        {}
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <SubclassSelector as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SubclassSelector> {
-    #[doc = "Calls [VisitMut`::visit_mut_subclass_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SupportsConditionType] {
+    #[doc = "Calls [VisitAstPath`::visit_supports_condition_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_subclass_selectors(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_supports_condition_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <SubclassSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <SupportsConditionType as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SupportsConditionType> {
-    #[doc = "Calls [VisitMut`::visit_mut_supports_condition_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [UrlModifier] {
+    #[doc = "Calls [VisitAstPath`::visit_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_supports_condition_types(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_url_modifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <SupportsConditionType as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <UrlModifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<UrlModifier> {
-    #[doc = "Calls [VisitMut`::visit_mut_url_modifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> VisitWithAstPath<V> for std::boxed::Box<T>
+where
+    V: ?Sized + VisitAstPath,
+    T: VisitWithAstPath<V>,
+{
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_url_modifiers(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v = <T as VisitWithAstPath<V>>::visit_with_ast_path(&**self, visitor, __ast_path);
+        v
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <UrlModifier as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v =
+            <T as VisitWithAstPath<V>>::visit_children_with_ast_path(&**self, visitor, __ast_path);
+        v
     }
 }
-impl<V, T> VisitMutWith<V> for std::boxed::Box<T>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> VisitWithAstPath<V> for std::vec::Vec<T>
 where
-    V: ?Sized + VisitMut,
-    T: VisitMutWith<V>,
+    V: ?Sized + VisitAstPath,
+    [T]: VisitWithAstPath<V>,
 {
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        let v = <T as VisitMutWith<V>>::visit_mut_with(&mut **self, visitor);
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v = <[T] as VisitWithAstPath<V>>::visit_with_ast_path(self, visitor, __ast_path);
         v
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v =
+            <[T] as VisitWithAstPath<V>>::visit_children_with_ast_path(self, visitor, __ast_path);
         v
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitMutAstPath {
+pub trait VisitMut {
     #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
-             [`AbsoluteColorBase::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`AbsoluteColorBase::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_absolute_color_base(
-        &mut self,
-        node: &mut AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AbsoluteColorBase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
+        <AbsoluteColorBase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
-             [`AlphaValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AlphaValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
-        <AlphaValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
+        <AlphaValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
-             [`AnPlusB::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AnPlusB::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
-        <AnPlusB as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
+        <AnPlusB as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
-             [`AnPlusBNotation::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`AnPlusBNotation::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_an_plus_b_notation(
-        &mut self,
-        node: &mut AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AnPlusBNotation as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
+        <AnPlusBNotation as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
-             [`Angle::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Angle::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
-        <Angle as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_angle(&mut self, node: &mut Angle) {
+        <Angle as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
-             [`AnglePercentage::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`AnglePercentage::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_angle_percentage(
-        &mut self,
-        node: &mut AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AnglePercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
+        <AnglePercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
-             [`AnyNamespace::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AnyNamespace::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
-        <AnyNamespace as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
+        <AnyNamespace as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
-             [`AtRule::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AtRule::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
-        <AtRule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
+        <AtRule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
-             [`AtRuleName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AtRuleName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
-        <AtRuleName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
+        <AtRuleName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
-             [`AtRulePrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AtRulePrelude::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_at_rule_prelude(
-        &mut self,
-        node: &mut AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AtRulePrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
+        <AtRulePrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`swc_atoms :: Atom::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
-        <swc_atoms::Atom as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+        <swc_atoms::Atom as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
-             [`AttributeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`AttributeSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector(
-        &mut self,
-        node: &mut AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AttributeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
+        <AttributeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
-             [`AttributeSelectorMatcher::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`AttributeSelectorMatcher::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector_matcher(
-        &mut self,
-        node: &mut AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AttributeSelectorMatcher as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
+        <AttributeSelectorMatcher as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
-             calls [`AttributeSelectorMatcherValue::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`AttributeSelectorMatcherValue::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_attribute_selector_matcher_value(
         &mut self,
         node: &mut AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) {
-        < AttributeSelectorMatcherValue as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <AttributeSelectorMatcherValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
-             [`AttributeSelectorModifier::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`AttributeSelectorModifier::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector_modifier(
-        &mut self,
-        node: &mut AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AttributeSelectorModifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
+        <AttributeSelectorModifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
-             [`AttributeSelectorValue::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`AttributeSelectorValue::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_attribute_selector_value(
-        &mut self,
-        node: &mut AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AttributeSelectorValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
+        <AttributeSelectorValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
-             [`BinOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`BinOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
-        <BinOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
+        <BinOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
-             [`CalcOperator::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CalcOperator::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
-        <CalcOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
+        <CalcOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
-             [`CalcOperatorType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CalcOperatorType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_calc_operator_type(
-        &mut self,
-        node: &mut CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CalcOperatorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
+        <CalcOperatorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
-             [`CalcProduct::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CalcProduct::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
-        <CalcProduct as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
+        <CalcProduct as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
-             [`CalcProductOrOperator::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`CalcProductOrOperator::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_calc_product_or_operator(
-        &mut self,
-        node: &mut CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CalcProductOrOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
+        <CalcProductOrOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
-             calls [`Vec < CalcProductOrOperator >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Vec < CalcProductOrOperator >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_calc_product_or_operators(
-        &mut self,
-        node: &mut Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<CalcProductOrOperator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
+        <Vec<CalcProductOrOperator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
-             [`CalcSum::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CalcSum::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
-        <CalcSum as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
+        <CalcSum as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
-             [`CalcValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CalcValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
-        <CalcValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
+        <CalcValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
-             [`CalcValueOrOperator::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`CalcValueOrOperator::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_calc_value_or_operator(
-        &mut self,
-        node: &mut CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CalcValueOrOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
+        <CalcValueOrOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
-             [`Vec < CalcValueOrOperator >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < CalcValueOrOperator >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_calc_value_or_operators(
-        &mut self,
-        node: &mut Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<CalcValueOrOperator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
+        <Vec<CalcValueOrOperator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
-             [`ClassSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ClassSelector::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
-        <ClassSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
+        <ClassSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
-             [`CmykComponent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CmykComponent::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
-        <CmykComponent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
+        <CmykComponent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
-             [`Color::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Color::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
-        <Color as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_color(&mut self, node: &mut Color) {
+        <Color as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
-             [`ColorProfileName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ColorProfileName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_color_profile_name(
-        &mut self,
-        node: &mut ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ColorProfileName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
+        <ColorProfileName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
-             [`Combinator::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Combinator::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
-        <Combinator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
+        <Combinator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
-             [`CombinatorValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CombinatorValue::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_combinator_value(
-        &mut self,
-        node: &mut CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CombinatorValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
+        <CombinatorValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
-             [`ComplexSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ComplexSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_complex_selector(
-        &mut self,
-        node: &mut ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ComplexSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
+        <ComplexSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
-             [`ComplexSelectorChildren::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`ComplexSelectorChildren::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_complex_selector_children(
-        &mut self,
-        node: &mut ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ComplexSelectorChildren as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
+        <ComplexSelectorChildren as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
-             calls [`Vec < ComplexSelectorChildren >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Vec < ComplexSelectorChildren >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_complex_selector_childrens(
-        &mut self,
-        node: &mut Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Vec < ComplexSelectorChildren > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
+        <Vec<ComplexSelectorChildren> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
-             [`Vec < ComplexSelector >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < ComplexSelector >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_complex_selectors(
-        &mut self,
-        node: &mut Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ComplexSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
+        <Vec<ComplexSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
-             [`ComponentValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ComponentValue::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_component_value(
-        &mut self,
-        node: &mut ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ComponentValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
+        <ComponentValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
-             < ComponentValue >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < ComponentValue >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_component_values(
-        &mut self,
-        node: &mut Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ComponentValue> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
+        <Vec<ComponentValue> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
-             [`CompoundSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CompoundSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_compound_selector(
-        &mut self,
-        node: &mut CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CompoundSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
+        <CompoundSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
-             [`CompoundSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`CompoundSelectorList::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_compound_selector_list(
-        &mut self,
-        node: &mut CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CompoundSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
+        <CompoundSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
-             [`Vec < CompoundSelector >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < CompoundSelector >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_compound_selectors(
-        &mut self,
-        node: &mut Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<CompoundSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
+        <Vec<CompoundSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
-             [`ContainerCondition::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ContainerCondition::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_container_condition(
-        &mut self,
-        node: &mut ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ContainerCondition as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
+        <ContainerCondition as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
-             [`ContainerName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ContainerName::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
-        <ContainerName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
+        <ContainerName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
-             [`ContainerQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ContainerQuery::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_container_query(
-        &mut self,
-        node: &mut ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ContainerQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
+        <ContainerQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
-             [`ContainerQueryAnd::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ContainerQueryAnd::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_container_query_and(
-        &mut self,
-        node: &mut ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ContainerQueryAnd as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
+        <ContainerQueryAnd as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
-             [`ContainerQueryNot::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ContainerQueryNot::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_container_query_not(
-        &mut self,
-        node: &mut ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ContainerQueryNot as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
+        <ContainerQueryNot as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
-             [`ContainerQueryOr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ContainerQueryOr::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_container_query_or(
-        &mut self,
-        node: &mut ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ContainerQueryOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
+        <ContainerQueryOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
-             [`ContainerQueryType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ContainerQueryType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_container_query_type(
-        &mut self,
-        node: &mut ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ContainerQueryType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
+        <ContainerQueryType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
-             [`Vec < ContainerQueryType >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < ContainerQueryType >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_container_query_types(
-        &mut self,
-        node: &mut Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ContainerQueryType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
+        <Vec<ContainerQueryType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
-             [`CustomHighlightName::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`CustomHighlightName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_custom_highlight_name(
-        &mut self,
-        node: &mut CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CustomHighlightName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
+        <CustomHighlightName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
-             [`CustomIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CustomIdent::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
-        <CustomIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
+        <CustomIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
-             CustomIdent >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             CustomIdent >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_custom_idents(
-        &mut self,
-        node: &mut Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<CustomIdent> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
+        <Vec<CustomIdent> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
-             [`CustomMediaQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CustomMediaQuery::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_custom_media_query(
-        &mut self,
-        node: &mut CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CustomMediaQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
+        <CustomMediaQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
-             [`CustomMediaQueryMediaType::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`CustomMediaQueryMediaType::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_custom_media_query_media_type(
-        &mut self,
-        node: &mut CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CustomMediaQueryMediaType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
+        <CustomMediaQueryMediaType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
-             [`CustomPropertyName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CustomPropertyName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_custom_property_name(
-        &mut self,
-        node: &mut CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <CustomPropertyName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
+        <CustomPropertyName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
-             [`DashedIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`DashedIdent::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
-        <DashedIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
+        <DashedIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
-             [`Declaration::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Declaration::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
-        <Declaration as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
+        <Declaration as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
-             [`DeclarationName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`DeclarationName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_declaration_name(
-        &mut self,
-        node: &mut DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <DeclarationName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
+        <DeclarationName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
-             [`DeclarationOrAtRule::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`DeclarationOrAtRule::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_declaration_or_at_rule(
-        &mut self,
-        node: &mut DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <DeclarationOrAtRule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
+        <DeclarationOrAtRule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
-             [`Delimiter::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Delimiter::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
-        <Delimiter as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
+        <Delimiter as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
-             [`DelimiterValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`DelimiterValue::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_delimiter_value(
-        &mut self,
-        node: &mut DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <DelimiterValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
+        <DelimiterValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
-             [`Dimension::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Dimension::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
-        <Dimension as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
+        <Dimension as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
-    #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
-             [`DimensionToken::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_mut_dimension_token(
-        &mut self,
-        node: &mut DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <DimensionToken as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
+             [`DimensionToken::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
+    #[inline]
+    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
+        <DimensionToken as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
-             [`DocumentPrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`DocumentPrelude::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_document_prelude(
-        &mut self,
-        node: &mut DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <DocumentPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
+        <DocumentPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
-             calls [`DocumentPreludeMatchingFunction::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`DocumentPreludeMatchingFunction::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_document_prelude_matching_function(
         &mut self,
         node: &mut DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) {
-        < DocumentPreludeMatchingFunction as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <DocumentPreludeMatchingFunction as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
-             method calls [`Vec < DocumentPreludeMatchingFunction \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Vec < DocumentPreludeMatchingFunction >::visit_mut_children_with`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_document_prelude_matching_functions(
         &mut self,
         node: &mut Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Vec < DocumentPreludeMatchingFunction > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Vec<DocumentPreludeMatchingFunction> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
-             [`ExtensionName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ExtensionName::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
-        <ExtensionName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
+        <ExtensionName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
-             [`FamilyName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`FamilyName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
-        <FamilyName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
+        <FamilyName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
-             FamilyName >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             FamilyName >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
-        <Vec<FamilyName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
+        <Vec<FamilyName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
-             [`Flex::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Flex::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
-        <Flex as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_flex(&mut self, node: &mut Flex) {
+        <Flex as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
-             [`FontFeatureValuesPrelude::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`FontFeatureValuesPrelude::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_font_feature_values_prelude(
-        &mut self,
-        node: &mut FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <FontFeatureValuesPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
+        <FontFeatureValuesPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
-             [`ForgivingComplexSelector::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`ForgivingComplexSelector::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_forgiving_complex_selector(
-        &mut self,
-        node: &mut ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ForgivingComplexSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
+        <ForgivingComplexSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingComplexSelector >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Vec < ForgivingComplexSelector >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(
-        &mut self,
-        node: &mut Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Vec < ForgivingComplexSelector > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
+        <Vec<ForgivingComplexSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
-             [`ForgivingRelativeSelector::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`ForgivingRelativeSelector::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_forgiving_relative_selector(
-        &mut self,
-        node: &mut ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ForgivingRelativeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
+        <ForgivingRelativeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
-             calls [`ForgivingRelativeSelectorList::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`ForgivingRelativeSelectorList::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_forgiving_relative_selector_list(
         &mut self,
         node: &mut ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) {
-        < ForgivingRelativeSelectorList as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <ForgivingRelativeSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingRelativeSelector >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Vec < ForgivingRelativeSelector >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_forgiving_relative_selectors(
         &mut self,
         node: &mut Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Vec < ForgivingRelativeSelector > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Vec<ForgivingRelativeSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
-             [`ForgivingSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ForgivingSelectorList::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_forgiving_selector_list(
-        &mut self,
-        node: &mut ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ForgivingSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
+        <ForgivingSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
-             [`Frequency::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Frequency::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
-        <Frequency as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
+        <Frequency as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
-             [`FrequencyPercentage::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`FrequencyPercentage::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_frequency_percentage(
-        &mut self,
-        node: &mut FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <FrequencyPercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
+        <FrequencyPercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Function::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
-        <Function as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_function(&mut self, node: &mut Function) {
+        <Function as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
-             [`FunctionName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`FunctionName::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
-        <FunctionName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
+        <FunctionName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
-             [`GeneralEnclosed::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`GeneralEnclosed::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_general_enclosed(
-        &mut self,
-        node: &mut GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <GeneralEnclosed as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
+        <GeneralEnclosed as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
-             [`HexColor::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`HexColor::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
-        <HexColor as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
+        <HexColor as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
-             [`Hue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Hue::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
-        <Hue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_hue(&mut self, node: &mut Hue) {
+        <Hue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
-             [`IdSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`IdSelector::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
-        <IdSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
+        <IdSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Ident::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
-        <Ident as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
+        <Ident as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
-        <Vec<Ident> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
+        <Vec<Ident> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
-             [`ImportConditions::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ImportConditions::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_conditions(
-        &mut self,
-        node: &mut ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ImportConditions as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
+        <ImportConditions as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
-             [`ImportHref::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportHref::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
-        <ImportHref as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
+        <ImportHref as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
-             [`ImportLayerName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ImportLayerName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_layer_name(
-        &mut self,
-        node: &mut ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ImportLayerName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
+        <ImportLayerName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
-             [`ImportPrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ImportPrelude::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
-        <ImportPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
+        <ImportPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
-             [`ImportantFlag::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ImportantFlag::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
-        <ImportantFlag as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
+        <ImportantFlag as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
-             [`Integer::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Integer::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
-        <Integer as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_integer(&mut self, node: &mut Integer) {
+        <Integer as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
-             [`KeyframeBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`KeyframeBlock::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
-        <KeyframeBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
+        <KeyframeBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
-             [`KeyframeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`KeyframeSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_keyframe_selector(
-        &mut self,
-        node: &mut KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <KeyframeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
+        <KeyframeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
-             [`Vec < KeyframeSelector >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < KeyframeSelector >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_keyframe_selectors(
-        &mut self,
-        node: &mut Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<KeyframeSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
+        <Vec<KeyframeSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
-             [`KeyframesName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`KeyframesName::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
-        <KeyframesName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
+        <KeyframesName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
-             [`KeyframesPseudoFunction::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`KeyframesPseudoFunction::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(
-        &mut self,
-        node: &mut KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <KeyframesPseudoFunction as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
+        <KeyframesPseudoFunction as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
-             [`KeyframesPseudoPrefix::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`KeyframesPseudoPrefix::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(
-        &mut self,
-        node: &mut KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <KeyframesPseudoPrefix as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
+        <KeyframesPseudoPrefix as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
-             [`LayerName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`LayerName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
-        <LayerName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
+        <LayerName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
-             [`LayerNameList::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`LayerNameList::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_layer_name_list(
-        &mut self,
-        node: &mut LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <LayerNameList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
+        <LayerNameList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
-             LayerName >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             LayerName >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
-        <Vec<LayerName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
+        <Vec<LayerName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
-             [`LayerPrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`LayerPrelude::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
-        <LayerPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
+        <LayerPrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
-             [`Length::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Length::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
-        <Length as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_length(&mut self, node: &mut Length) {
+        <Length as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
-             [`LengthPercentage::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`LengthPercentage::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_length_percentage(
-        &mut self,
-        node: &mut LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <LengthPercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
+        <LengthPercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
-             [`ListOfComponentValues::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ListOfComponentValues::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_list_of_component_values(
-        &mut self,
-        node: &mut ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ListOfComponentValues as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
+        <ListOfComponentValues as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
-             [`MediaAnd::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaAnd::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
-        <MediaAnd as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
+        <MediaAnd as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
-             [`MediaCondition::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_mut_media_condition(
-        &mut self,
-        node: &mut MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaCondition as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+             [`MediaCondition::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
+    #[inline]
+    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
+        <MediaCondition as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
-             [`MediaConditionAllType::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`MediaConditionAllType::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_all_type(
-        &mut self,
-        node: &mut MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaConditionAllType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
+        <MediaConditionAllType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
-             calls [`Vec < MediaConditionAllType >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Vec < MediaConditionAllType >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_all_types(
-        &mut self,
-        node: &mut Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<MediaConditionAllType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
+        <Vec<MediaConditionAllType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
-             [`MediaConditionType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaConditionType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_media_condition_type(
-        &mut self,
-        node: &mut MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaConditionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
+        <MediaConditionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOr::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`MediaConditionWithoutOr::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_media_condition_without_or(
-        &mut self,
-        node: &mut MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaConditionWithoutOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
+        <MediaConditionWithoutOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOrType::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`MediaConditionWithoutOrType::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
     fn visit_mut_media_condition_without_or_type(
         &mut self,
         node: &mut MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) {
-        <MediaConditionWithoutOrType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <MediaConditionWithoutOrType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
-             method calls [`Vec < MediaConditionWithoutOrType \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Vec < MediaConditionWithoutOrType >::visit_mut_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_media_condition_without_or_types(
         &mut self,
         node: &mut Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Vec < MediaConditionWithoutOrType > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Vec<MediaConditionWithoutOrType> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
-             [`MediaFeature::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaFeature::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
-        <MediaFeature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
+        <MediaFeature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
-             [`MediaFeatureBoolean::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`MediaFeatureBoolean::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_media_feature_boolean(
-        &mut self,
-        node: &mut MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaFeatureBoolean as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
+        <MediaFeatureBoolean as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
-             [`MediaFeatureName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaFeatureName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_media_feature_name(
-        &mut self,
-        node: &mut MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaFeatureName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
+        <MediaFeatureName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
-             [`MediaFeaturePlain::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaFeaturePlain::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_media_feature_plain(
-        &mut self,
-        node: &mut MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaFeaturePlain as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
+        <MediaFeaturePlain as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
-             [`MediaFeatureRange::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaFeatureRange::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_media_feature_range(
-        &mut self,
-        node: &mut MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaFeatureRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
+        <MediaFeatureRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeComparison::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`MediaFeatureRangeComparison::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_range_comparison(
-        &mut self,
-        node: &mut MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaFeatureRangeComparison as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
+        <MediaFeatureRangeComparison as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeInterval::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`MediaFeatureRangeInterval::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_media_feature_range_interval(
-        &mut self,
-        node: &mut MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaFeatureRangeInterval as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
+        <MediaFeatureRangeInterval as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
-             [`MediaFeatureValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaFeatureValue::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_media_feature_value(
-        &mut self,
-        node: &mut MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaFeatureValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
+        <MediaFeatureValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
-             [`MediaInParens::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaInParens::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_media_in_parens(
-        &mut self,
-        node: &mut MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaInParens as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
+        <MediaInParens as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
-             [`MediaNot::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaNot::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
-        <MediaNot as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
+        <MediaNot as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
-             [`MediaOr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaOr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
-        <MediaOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
+        <MediaOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
-             [`MediaQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaQuery::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
-        <MediaQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
+        <MediaQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
-             [`MediaQueryList::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaQueryList::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_media_query_list(
-        &mut self,
-        node: &mut MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <MediaQueryList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
+        <MediaQueryList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
-             MediaQuery >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             MediaQuery >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
-        <Vec<MediaQuery> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
+        <Vec<MediaQuery> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
-             [`MediaType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
-        <MediaType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
+        <MediaType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
-             [`NamedNamespace::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`NamedNamespace::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_named_namespace(
-        &mut self,
-        node: &mut NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <NamedNamespace as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
+        <NamedNamespace as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Namespace::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
-        <Namespace as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
+        <Namespace as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
-             [`NamespacePrefix::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`NamespacePrefix::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_namespace_prefix(
-        &mut self,
-        node: &mut NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <NamespacePrefix as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
+        <NamespacePrefix as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
-             [`NamespacePrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`NamespacePrelude::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_namespace_prelude(
-        &mut self,
-        node: &mut NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <NamespacePrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
+        <NamespacePrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
-             [`NamespacePreludeUri::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`NamespacePreludeUri::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_namespace_prelude_uri(
-        &mut self,
-        node: &mut NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <NamespacePreludeUri as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
+        <NamespacePreludeUri as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
-             [`NestingSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`NestingSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_nesting_selector(
-        &mut self,
-        node: &mut NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <NestingSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
+        <NestingSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Number::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
-        <Number as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_number(&mut self, node: &mut Number) {
+        <Number as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
-             [`NumberType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`NumberType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
-        <NumberType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
+        <NumberType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
-             calls [`Option < Box < AtRulePrelude > >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < Box < AtRulePrelude > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(
-        &mut self,
-        node: &mut Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<AtRulePrelude>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
+        <Option<Box<AtRulePrelude>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < swc_atoms :: Atom >::visit_mut_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<swc_atoms::Atom> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+        <Option<swc_atoms::Atom> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorMatcher \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Option < AttributeSelectorMatcher >::visit_mut_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
         node: &mut Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Option < AttributeSelectorMatcher > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Option<AttributeSelectorMatcher> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorModifier \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Option < AttributeSelectorModifier >::visit_mut_children_with`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
         node: &mut Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Option < AttributeSelectorModifier > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Option<AttributeSelectorModifier> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
-             calls [`Option < AttributeSelectorValue >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < AttributeSelectorValue >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_opt_attribute_selector_value(
         &mut self,
         node: &mut Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Option < AttributeSelectorValue > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Option<AttributeSelectorValue> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
-             [`Option < Combinator >::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Combinator >::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_combinator(
-        &mut self,
-        node: &mut Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Combinator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
+        <Option<Combinator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
-             [`Option < ContainerName >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < ContainerName >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_container_name(
-        &mut self,
-        node: &mut Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<ContainerName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
+        <Option<ContainerName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
-             calls [`Option < ForgivingSelectorList >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < ForgivingSelectorList >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(
-        &mut self,
-        node: &mut Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Option < ForgivingSelectorList > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
+        <Option<ForgivingSelectorList> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
-             [`Option < Box < Function > >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < Function > >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_function(
-        &mut self,
-        node: &mut Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<Function>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
+        <Option<Box<Function>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             Ident >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
-        <Option<Ident> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+        <Option<Ident> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
-             method calls [`Option < Box < ImportConditions > \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Option < Box < ImportConditions > >::visit_mut_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_import_conditions(
-        &mut self,
-        node: &mut Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Option < Box < ImportConditions > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
+        <Option<Box<ImportConditions>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
-             calls [`Option < Box < ImportLayerName > >::visit_mut_children_with_ast_path`]. If \
-             you want to recurse, you need to call it manually."]
+             calls [`Option < Box < ImportLayerName > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_import_layer_name(
-        &mut self,
-        node: &mut Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Option < Box < ImportLayerName > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
+        <Option<Box<ImportLayerName>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
-             [`Option < ImportantFlag >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < ImportantFlag >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_important_flag(
-        &mut self,
-        node: &mut Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<ImportantFlag> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
+        <Option<ImportantFlag> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
-             method calls [`Option < Box < MediaConditionType > \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Option < Box < MediaConditionType > >::visit_mut_children_with`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_media_condition_type(
-        &mut self,
-        node: &mut Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Option < Box < MediaConditionType > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
+        <Option<Box<MediaConditionType>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
-             calls [`Option < Box < MediaQueryList > >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < Box < MediaQueryList > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_media_query_list(
-        &mut self,
-        node: &mut Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<MediaQueryList>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
+        <Option<Box<MediaQueryList>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
-             [`Option < MediaType >::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < MediaType >::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_media_type(
-        &mut self,
-        node: &mut Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<MediaType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
+        <Option<MediaType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Namespace >::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_namespace(
-        &mut self,
-        node: &mut Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Namespace> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
+        <Option<Namespace> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
-             [`Option < NamespacePrefix >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < NamespacePrefix >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_namespace_prefix(
-        &mut self,
-        node: &mut Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<NamespacePrefix> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
+        <Option<NamespacePrefix> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
-             [`Option < NestingSelector >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < NestingSelector >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_nesting_selector(
-        &mut self,
-        node: &mut Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<NestingSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
+        <Option<NestingSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
-             Number >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             Number >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
-        <Option<Number> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
+        <Option<Number> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
-             method calls [`Option < Vec < PageSelectorPseudo > \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Option < Vec < PageSelectorPseudo > >::visit_mut_children_with`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(
-        &mut self,
-        node: &mut Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Option < Vec < PageSelectorPseudo > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
+        <Option<Vec<PageSelectorPseudo>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
-             [`Option < PageSelectorType >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < PageSelectorType >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_page_selector_type(
-        &mut self,
-        node: &mut Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<PageSelectorType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
+        <Option<PageSelectorType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
              this method calls [`Option < Vec < PseudoClassSelectorChildren > \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Option < Vec < PseudoClassSelectorChildren > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Option<Vec<PseudoClassSelectorChildren>> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
              default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Option < Vec < PseudoElementSelectorChildren > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Option<Vec<PseudoElementSelectorChildren>> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
-             [`Option < SimpleBlock >::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < SimpleBlock >::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_simple_block(
-        &mut self,
-        node: &mut Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<SimpleBlock> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
+        <Option<SimpleBlock> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
-             calls [`Option < Box < TypeSelector > >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < Box < TypeSelector > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_type_selector(
-        &mut self,
-        node: &mut Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<TypeSelector>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
+        <Option<Box<TypeSelector>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
-             calls [`Option < Vec < UrlModifier > >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < Vec < UrlModifier > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_url_modifiers(
-        &mut self,
-        node: &mut Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Vec<UrlModifier>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
+        <Option<Vec<UrlModifier>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
-             [`Option < Box < UrlValue > >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < UrlValue > >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_url_value(
-        &mut self,
-        node: &mut Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<UrlValue>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
+        <Option<Box<UrlValue>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
-             [`PageSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PageSelector::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
-        <PageSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
+        <PageSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
-             [`PageSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`PageSelectorList::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_page_selector_list(
-        &mut self,
-        node: &mut PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <PageSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
+        <PageSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
-             [`PageSelectorPseudo::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`PageSelectorPseudo::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_page_selector_pseudo(
-        &mut self,
-        node: &mut PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <PageSelectorPseudo as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
+        <PageSelectorPseudo as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
-             [`Vec < PageSelectorPseudo >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < PageSelectorPseudo >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_page_selector_pseudos(
-        &mut self,
-        node: &mut Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<PageSelectorPseudo> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
+        <Vec<PageSelectorPseudo> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
-             [`PageSelectorType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`PageSelectorType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_page_selector_type(
-        &mut self,
-        node: &mut PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <PageSelectorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
+        <PageSelectorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
-             PageSelector >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             PageSelector >::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_page_selectors(
-        &mut self,
-        node: &mut Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<PageSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
+        <Vec<PageSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
-             [`Percentage::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Percentage::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
-        <Percentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
+        <Percentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
-             [`PseudoClassSelector::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`PseudoClassSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_pseudo_class_selector(
-        &mut self,
-        node: &mut PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <PseudoClassSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
+        <PseudoClassSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
-             [`PseudoClassSelectorChildren::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`PseudoClassSelectorChildren::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(
-        &mut self,
-        node: &mut PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <PseudoClassSelectorChildren as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
+        <PseudoClassSelectorChildren as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoClassSelectorChildren \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Vec < PseudoClassSelectorChildren >::visit_mut_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Vec < PseudoClassSelectorChildren > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Vec<PseudoClassSelectorChildren> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
-             [`PseudoElementSelector::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`PseudoElementSelector::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_pseudo_element_selector(
-        &mut self,
-        node: &mut PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <PseudoElementSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
+        <PseudoElementSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
-             calls [`PseudoElementSelectorChildren::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`PseudoElementSelectorChildren::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_pseudo_element_selector_children(
         &mut self,
         node: &mut PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) {
-        < PseudoElementSelectorChildren as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <PseudoElementSelectorChildren as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoElementSelectorChildren \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Vec < PseudoElementSelectorChildren >::visit_mut_children_with`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Vec < PseudoElementSelectorChildren > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Vec<PseudoElementSelectorChildren> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
-             [`QualifiedRule::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`QualifiedRule::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
-        <QualifiedRule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
+        <QualifiedRule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
-             [`QualifiedRulePrelude::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`QualifiedRulePrelude::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_qualified_rule_prelude(
-        &mut self,
-        node: &mut QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <QualifiedRulePrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
+        <QualifiedRulePrelude as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
-             [`QueryInParens::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`QueryInParens::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_query_in_parens(
-        &mut self,
-        node: &mut QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <QueryInParens as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
+        <QueryInParens as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
-             [`Ratio::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Ratio::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
-        <Ratio as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
+        <Ratio as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
-             [`RelativeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`RelativeSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_relative_selector(
-        &mut self,
-        node: &mut RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <RelativeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
+        <RelativeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
-             [`RelativeSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`RelativeSelectorList::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_relative_selector_list(
-        &mut self,
-        node: &mut RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <RelativeSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
+        <RelativeSelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
-             [`Vec < RelativeSelector >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < RelativeSelector >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_relative_selectors(
-        &mut self,
-        node: &mut Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<RelativeSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
+        <Vec<RelativeSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
-             [`Resolution::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Resolution::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
-        <Resolution as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
+        <Resolution as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
-             [`Rule::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Rule::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
-        <Rule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_rule(&mut self, node: &mut Rule) {
+        <Rule as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
-        <Vec<Rule> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
+        <Vec<Rule> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
-             [`ScopeRange::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ScopeRange::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
-        <ScopeRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
+        <ScopeRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
-             [`SelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
-        <SelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
-             [`SequenceOfCustomIdents::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`SelectorList::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(
-        &mut self,
-        node: &mut SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SequenceOfCustomIdents as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
+        <SelectorList as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
-    #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
-             [`SimpleBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+    #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
+             [`SequenceOfCustomIdents::visit_mut_children_with`]. If you want to recurse, you need \
              to call it manually."]
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
-        <SimpleBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
+        <SequenceOfCustomIdents as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    }
+    #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
+             [`SimpleBlock::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
+    #[inline]
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
+        <SimpleBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
-             [`SizeFeature::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SizeFeature::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
-        <SizeFeature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
+        <SizeFeature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
-             [`SizeFeatureBoolean::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SizeFeatureBoolean::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_size_feature_boolean(
-        &mut self,
-        node: &mut SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SizeFeatureBoolean as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
+        <SizeFeatureBoolean as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
-             [`SizeFeatureName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SizeFeatureName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_size_feature_name(
-        &mut self,
-        node: &mut SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SizeFeatureName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
+        <SizeFeatureName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
-             [`SizeFeaturePlain::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SizeFeaturePlain::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_size_feature_plain(
-        &mut self,
-        node: &mut SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SizeFeaturePlain as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
+        <SizeFeaturePlain as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
-             [`SizeFeatureRange::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SizeFeatureRange::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_size_feature_range(
-        &mut self,
-        node: &mut SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SizeFeatureRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
+        <SizeFeatureRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeComparison::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`SizeFeatureRangeComparison::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_size_feature_range_comparison(
-        &mut self,
-        node: &mut SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SizeFeatureRangeComparison as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
+        <SizeFeatureRangeComparison as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeInterval::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`SizeFeatureRangeInterval::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_size_feature_range_interval(
-        &mut self,
-        node: &mut SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SizeFeatureRangeInterval as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
+        <SizeFeatureRangeInterval as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
-             [`SizeFeatureValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SizeFeatureValue::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_size_feature_value(
-        &mut self,
-        node: &mut SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SizeFeatureValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
+        <SizeFeatureValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`swc_common :: Span::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
-        <swc_common::Span as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+        <swc_common::Span as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Str::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
-        <Str as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_str(&mut self, node: &mut Str) {
+        <Str as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
-             [`StyleBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`StyleBlock::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
-        <StyleBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
+        <StyleBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
-             [`Stylesheet::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Stylesheet::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
-        <Stylesheet as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
+        <Stylesheet as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
-             [`SubclassSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SubclassSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_subclass_selector(
-        &mut self,
-        node: &mut SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SubclassSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
+        <SubclassSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
-             [`Vec < SubclassSelector >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < SubclassSelector >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_subclass_selectors(
-        &mut self,
-        node: &mut Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<SubclassSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
+        <Vec<SubclassSelector> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
-             [`SupportsAnd::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SupportsAnd::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
-        <SupportsAnd as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
+        <SupportsAnd as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
-             [`SupportsCondition::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SupportsCondition::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_supports_condition(
-        &mut self,
-        node: &mut SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SupportsCondition as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
+        <SupportsCondition as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
-             [`SupportsConditionType::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`SupportsConditionType::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_supports_condition_type(
-        &mut self,
-        node: &mut SupportsConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SupportsConditionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
+        <SupportsConditionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
-             calls [`Vec < SupportsConditionType >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Vec < SupportsConditionType >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_supports_condition_types(
-        &mut self,
-        node: &mut Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<SupportsConditionType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
+        <Vec<SupportsConditionType> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
-             [`SupportsFeature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SupportsFeature::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_supports_feature(
-        &mut self,
-        node: &mut SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SupportsFeature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
+        <SupportsFeature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
-             [`SupportsInParens::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SupportsInParens::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_supports_in_parens(
-        &mut self,
-        node: &mut SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SupportsInParens as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
+        <SupportsInParens as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
-             [`SupportsNot::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SupportsNot::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
-        <SupportsNot as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
+        <SupportsNot as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
-             [`SupportsOr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SupportsOr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
-        <SupportsOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
+        <SupportsOr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
-             [`TagNameSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TagNameSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_tag_name_selector(
-        &mut self,
-        node: &mut TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TagNameSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
+        <TagNameSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
-             [`Time::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Time::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
-        <Time as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_time(&mut self, node: &mut Time) {
+        <Time as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
-             [`TimePercentage::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TimePercentage::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_time_percentage(
-        &mut self,
-        node: &mut TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TimePercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
+        <TimePercentage as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Token::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
-        <Token as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_token(&mut self, node: &mut Token) {
+        <Token as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TokenAndSpan::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
-        <TokenAndSpan as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
+        <TokenAndSpan as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
-             [`TypeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TypeSelector::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
-        <TypeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
+        <TypeSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
-             [`UnicodeRange::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`UnicodeRange::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
-        <UnicodeRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
+        <UnicodeRange as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
-             [`UniversalSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`UniversalSelector::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_universal_selector(
-        &mut self,
-        node: &mut UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <UniversalSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
+        <UniversalSelector as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
-             [`UnknownDimension::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`UnknownDimension::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_unknown_dimension(
-        &mut self,
-        node: &mut UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <UnknownDimension as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
+        <UnknownDimension as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
-             [`Url::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Url::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
-        <Url as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_url(&mut self, node: &mut Url) {
+        <Url as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
-             [`UrlKeyValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`UrlKeyValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
-        <UrlKeyValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
+        <UrlKeyValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
-             [`UrlModifier::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`UrlModifier::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
-        <UrlModifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
+        <UrlModifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
-             UrlModifier >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             UrlModifier >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_url_modifiers(
-        &mut self,
-        node: &mut Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<UrlModifier> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
+        <Vec<UrlModifier> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
-             [`UrlValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UrlValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
-        <UrlValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
+        <UrlValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
-             [`UrlValueRaw::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`UrlValueRaw::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
-        <UrlValueRaw as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
+        <UrlValueRaw as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
-             [`WqName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`WqName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
-        <WqName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
+        <WqName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitMutAstPath for &mut V
+impl<V> VisitMut for &mut V
 where
-    V: ?Sized + VisitMutAstPath,
+    V: ?Sized + VisitMut,
 {
     #[inline]
-    fn visit_mut_absolute_color_base(
-        &mut self,
-        node: &mut AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_absolute_color_base(&mut **self, node, __ast_path)
+    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
+        <V as VisitMut>::visit_mut_absolute_color_base(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_alpha_value(&mut **self, node, __ast_path)
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
+        <V as VisitMut>::visit_mut_alpha_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_an_plus_b(&mut **self, node, __ast_path)
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
+        <V as VisitMut>::visit_mut_an_plus_b(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(
-        &mut self,
-        node: &mut AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(&mut **self, node, __ast_path)
+    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
+        <V as VisitMut>::visit_mut_an_plus_b_notation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_angle(&mut **self, node, __ast_path)
+    fn visit_mut_angle(&mut self, node: &mut Angle) {
+        <V as VisitMut>::visit_mut_angle(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(
-        &mut self,
-        node: &mut AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_angle_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
+        <V as VisitMut>::visit_mut_angle_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_any_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
+        <V as VisitMut>::visit_mut_any_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_at_rule(&mut **self, node, __ast_path)
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
+        <V as VisitMut>::visit_mut_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_at_rule_name(&mut **self, node, __ast_path)
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
+        <V as VisitMut>::visit_mut_at_rule_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(
-        &mut self,
-        node: &mut AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_at_rule_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
+        <V as VisitMut>::visit_mut_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+        <V as VisitMut>::visit_mut_atom(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(
-        &mut self,
-        node: &mut AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
+        <V as VisitMut>::visit_mut_attribute_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(
-        &mut self,
-        node: &mut AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
+        <V as VisitMut>::visit_mut_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_attribute_selector_matcher_value(
         &mut self,
         node: &mut AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_attribute_selector_matcher_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(
-        &mut self,
-        node: &mut AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
+        <V as VisitMut>::visit_mut_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(
-        &mut self,
-        node: &mut AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_value(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
+        <V as VisitMut>::visit_mut_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bin_op(&mut **self, node, __ast_path)
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
+        <V as VisitMut>::visit_mut_bin_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_operator(&mut **self, node, __ast_path)
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
+        <V as VisitMut>::visit_mut_calc_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(
-        &mut self,
-        node: &mut CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_operator_type(&mut **self, node, __ast_path)
+    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
+        <V as VisitMut>::visit_mut_calc_operator_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_product(&mut **self, node, __ast_path)
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
+        <V as VisitMut>::visit_mut_calc_product(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(
-        &mut self,
-        node: &mut CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(&mut **self, node, __ast_path)
+    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
+        <V as VisitMut>::visit_mut_calc_product_or_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(
-        &mut self,
-        node: &mut Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(&mut **self, node, __ast_path)
+    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
+        <V as VisitMut>::visit_mut_calc_product_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_sum(&mut **self, node, __ast_path)
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
+        <V as VisitMut>::visit_mut_calc_sum(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_value(&mut **self, node, __ast_path)
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
+        <V as VisitMut>::visit_mut_calc_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(
-        &mut self,
-        node: &mut CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(&mut **self, node, __ast_path)
+    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
+        <V as VisitMut>::visit_mut_calc_value_or_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(
-        &mut self,
-        node: &mut Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(&mut **self, node, __ast_path)
+    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
+        <V as VisitMut>::visit_mut_calc_value_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_selector(&mut **self, node, __ast_path)
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
+        <V as VisitMut>::visit_mut_class_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_cmyk_component(&mut **self, node, __ast_path)
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
+        <V as VisitMut>::visit_mut_cmyk_component(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_color(&mut **self, node, __ast_path)
+    fn visit_mut_color(&mut self, node: &mut Color) {
+        <V as VisitMut>::visit_mut_color(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(
-        &mut self,
-        node: &mut ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_color_profile_name(&mut **self, node, __ast_path)
+    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
+        <V as VisitMut>::visit_mut_color_profile_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_combinator(&mut **self, node, __ast_path)
+    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
+        <V as VisitMut>::visit_mut_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_combinator_value(
-        &mut self,
-        node: &mut CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_combinator_value(&mut **self, node, __ast_path)
+    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
+        <V as VisitMut>::visit_mut_combinator_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selector(
-        &mut self,
-        node: &mut ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
+        <V as VisitMut>::visit_mut_complex_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(
-        &mut self,
-        node: &mut ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector_children(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
+        <V as VisitMut>::visit_mut_complex_selector_children(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(
-        &mut self,
-        node: &mut Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
+        <V as VisitMut>::visit_mut_complex_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(
-        &mut self,
-        node: &mut Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
+        <V as VisitMut>::visit_mut_complex_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_component_value(
-        &mut self,
-        node: &mut ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_component_value(&mut **self, node, __ast_path)
+    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
+        <V as VisitMut>::visit_mut_component_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_component_values(
-        &mut self,
-        node: &mut Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_component_values(&mut **self, node, __ast_path)
+    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
+        <V as VisitMut>::visit_mut_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_compound_selector(
-        &mut self,
-        node: &mut CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_compound_selector(&mut **self, node, __ast_path)
+    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
+        <V as VisitMut>::visit_mut_compound_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(
-        &mut self,
-        node: &mut CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_compound_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
+        <V as VisitMut>::visit_mut_compound_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(
-        &mut self,
-        node: &mut Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_compound_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
+        <V as VisitMut>::visit_mut_compound_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_condition(
-        &mut self,
-        node: &mut ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_condition(&mut **self, node, __ast_path)
+    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
+        <V as VisitMut>::visit_mut_container_condition(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_name(&mut **self, node, __ast_path)
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
+        <V as VisitMut>::visit_mut_container_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query(
-        &mut self,
-        node: &mut ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query(&mut **self, node, __ast_path)
+    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
+        <V as VisitMut>::visit_mut_container_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_and(
-        &mut self,
-        node: &mut ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_and(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
+        <V as VisitMut>::visit_mut_container_query_and(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_not(
-        &mut self,
-        node: &mut ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_not(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
+        <V as VisitMut>::visit_mut_container_query_not(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_or(
-        &mut self,
-        node: &mut ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_or(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
+        <V as VisitMut>::visit_mut_container_query_or(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_type(
-        &mut self,
-        node: &mut ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_type(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
+        <V as VisitMut>::visit_mut_container_query_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_types(
-        &mut self,
-        node: &mut Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_types(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
+        <V as VisitMut>::visit_mut_container_query_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(
-        &mut self,
-        node: &mut CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_highlight_name(&mut **self, node, __ast_path)
+    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
+        <V as VisitMut>::visit_mut_custom_highlight_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_ident(&mut **self, node, __ast_path)
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
+        <V as VisitMut>::visit_mut_custom_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_idents(
-        &mut self,
-        node: &mut Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_idents(&mut **self, node, __ast_path)
+    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
+        <V as VisitMut>::visit_mut_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(
-        &mut self,
-        node: &mut CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_media_query(&mut **self, node, __ast_path)
+    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
+        <V as VisitMut>::visit_mut_custom_media_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(
-        &mut self,
-        node: &mut CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
+        <V as VisitMut>::visit_mut_custom_media_query_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(
-        &mut self,
-        node: &mut CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_property_name(&mut **self, node, __ast_path)
+    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
+        <V as VisitMut>::visit_mut_custom_property_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_dashed_ident(&mut **self, node, __ast_path)
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
+        <V as VisitMut>::visit_mut_dashed_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_declaration(&mut **self, node, __ast_path)
+    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
+        <V as VisitMut>::visit_mut_declaration(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_declaration_name(
-        &mut self,
-        node: &mut DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_declaration_name(&mut **self, node, __ast_path)
+    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
+        <V as VisitMut>::visit_mut_declaration_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(
-        &mut self,
-        node: &mut DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(&mut **self, node, __ast_path)
+    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
+        <V as VisitMut>::visit_mut_declaration_or_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_delimiter(&mut **self, node, __ast_path)
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
+        <V as VisitMut>::visit_mut_delimiter(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(
-        &mut self,
-        node: &mut DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_delimiter_value(&mut **self, node, __ast_path)
+    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
+        <V as VisitMut>::visit_mut_delimiter_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_dimension(&mut **self, node, __ast_path)
+    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
+        <V as VisitMut>::visit_mut_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_dimension_token(
-        &mut self,
-        node: &mut DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_dimension_token(&mut **self, node, __ast_path)
+    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
+        <V as VisitMut>::visit_mut_dimension_token(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_document_prelude(
-        &mut self,
-        node: &mut DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
+        <V as VisitMut>::visit_mut_document_prelude(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_document_prelude_matching_function(
         &mut self,
         node: &mut DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_document_prelude_matching_function(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_document_prelude_matching_functions(
         &mut self,
         node: &mut Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_document_prelude_matching_functions(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_extension_name(&mut **self, node, __ast_path)
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
+        <V as VisitMut>::visit_mut_extension_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_family_name(&mut **self, node, __ast_path)
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
+        <V as VisitMut>::visit_mut_family_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_family_names(&mut **self, node, __ast_path)
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
+        <V as VisitMut>::visit_mut_family_names(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_flex(&mut **self, node, __ast_path)
+    fn visit_mut_flex(&mut self, node: &mut Flex) {
+        <V as VisitMut>::visit_mut_flex(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(
-        &mut self,
-        node: &mut FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
+        <V as VisitMut>::visit_mut_font_feature_values_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(
-        &mut self,
-        node: &mut ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
+        <V as VisitMut>::visit_mut_forgiving_complex_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(
-        &mut self,
-        node: &mut Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
+        <V as VisitMut>::visit_mut_forgiving_complex_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(
-        &mut self,
-        node: &mut ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
+        <V as VisitMut>::visit_mut_forgiving_relative_selector(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_forgiving_relative_selector_list(
         &mut self,
         node: &mut ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_forgiving_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_forgiving_relative_selectors(
         &mut self,
         node: &mut Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_forgiving_relative_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_forgiving_selector_list(
-        &mut self,
-        node: &mut ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
+        <V as VisitMut>::visit_mut_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_frequency(&mut **self, node, __ast_path)
+    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
+        <V as VisitMut>::visit_mut_frequency(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(
-        &mut self,
-        node: &mut FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_frequency_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
+        <V as VisitMut>::visit_mut_frequency_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
+    fn visit_mut_function(&mut self, node: &mut Function) {
+        <V as VisitMut>::visit_mut_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function_name(&mut **self, node, __ast_path)
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
+        <V as VisitMut>::visit_mut_function_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(
-        &mut self,
-        node: &mut GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_general_enclosed(&mut **self, node, __ast_path)
+    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
+        <V as VisitMut>::visit_mut_general_enclosed(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_hex_color(&mut **self, node, __ast_path)
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
+        <V as VisitMut>::visit_mut_hex_color(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_hue(&mut **self, node, __ast_path)
+    fn visit_mut_hue(&mut self, node: &mut Hue) {
+        <V as VisitMut>::visit_mut_hue(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_id_selector(&mut **self, node, __ast_path)
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
+        <V as VisitMut>::visit_mut_id_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
+        <V as VisitMut>::visit_mut_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_idents(&mut **self, node, __ast_path)
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
+        <V as VisitMut>::visit_mut_idents(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_conditions(
-        &mut self,
-        node: &mut ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_conditions(&mut **self, node, __ast_path)
+    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
+        <V as VisitMut>::visit_mut_import_conditions(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_href(&mut **self, node, __ast_path)
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
+        <V as VisitMut>::visit_mut_import_href(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(
-        &mut self,
-        node: &mut ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_layer_name(&mut **self, node, __ast_path)
+    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
+        <V as VisitMut>::visit_mut_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
+        <V as VisitMut>::visit_mut_import_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_important_flag(&mut **self, node, __ast_path)
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
+        <V as VisitMut>::visit_mut_important_flag(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_integer(&mut **self, node, __ast_path)
+    fn visit_mut_integer(&mut self, node: &mut Integer) {
+        <V as VisitMut>::visit_mut_integer(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_block(&mut **self, node, __ast_path)
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
+        <V as VisitMut>::visit_mut_keyframe_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(
-        &mut self,
-        node: &mut KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_selector(&mut **self, node, __ast_path)
+    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
+        <V as VisitMut>::visit_mut_keyframe_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(
-        &mut self,
-        node: &mut Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
+        <V as VisitMut>::visit_mut_keyframe_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_name(&mut **self, node, __ast_path)
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
+        <V as VisitMut>::visit_mut_keyframes_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(
-        &mut self,
-        node: &mut KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(&mut **self, node, __ast_path)
+    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
+        <V as VisitMut>::visit_mut_keyframes_pseudo_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(
-        &mut self,
-        node: &mut KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
+    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
+        <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_name(&mut **self, node, __ast_path)
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
+        <V as VisitMut>::visit_mut_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(
-        &mut self,
-        node: &mut LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_layer_name_list(&mut **self, node, __ast_path)
+    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
+        <V as VisitMut>::visit_mut_layer_name_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_names(&mut **self, node, __ast_path)
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
+        <V as VisitMut>::visit_mut_layer_names(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
+        <V as VisitMut>::visit_mut_layer_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_length(&mut **self, node, __ast_path)
+    fn visit_mut_length(&mut self, node: &mut Length) {
+        <V as VisitMut>::visit_mut_length(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_length_percentage(
-        &mut self,
-        node: &mut LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_length_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
+        <V as VisitMut>::visit_mut_length_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(
-        &mut self,
-        node: &mut ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_list_of_component_values(&mut **self, node, __ast_path)
+    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
+        <V as VisitMut>::visit_mut_list_of_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_and(&mut **self, node, __ast_path)
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
+        <V as VisitMut>::visit_mut_media_and(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition(
-        &mut self,
-        node: &mut MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
+        <V as VisitMut>::visit_mut_media_condition(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(
-        &mut self,
-        node: &mut MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_all_type(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
+        <V as VisitMut>::visit_mut_media_condition_all_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(
-        &mut self,
-        node: &mut Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_all_types(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
+        <V as VisitMut>::visit_mut_media_condition_all_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(
-        &mut self,
-        node: &mut MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_type(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
+        <V as VisitMut>::visit_mut_media_condition_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(
-        &mut self,
-        node: &mut MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
+        <V as VisitMut>::visit_mut_media_condition_without_or(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_media_condition_without_or_type(
         &mut self,
         node: &mut MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_media_condition_without_or_type(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_media_condition_without_or_types(
         &mut self,
         node: &mut Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_media_condition_without_or_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
+        <V as VisitMut>::visit_mut_media_feature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_boolean(
-        &mut self,
-        node: &mut MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_boolean(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
+        <V as VisitMut>::visit_mut_media_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(
-        &mut self,
-        node: &mut MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_name(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
+        <V as VisitMut>::visit_mut_media_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(
-        &mut self,
-        node: &mut MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_plain(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
+        <V as VisitMut>::visit_mut_media_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(
-        &mut self,
-        node: &mut MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
+        <V as VisitMut>::visit_mut_media_feature_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(
-        &mut self,
-        node: &mut MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
+        <V as VisitMut>::visit_mut_media_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(
-        &mut self,
-        node: &mut MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
+        <V as VisitMut>::visit_mut_media_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(
-        &mut self,
-        node: &mut MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_value(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
+        <V as VisitMut>::visit_mut_media_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(
-        &mut self,
-        node: &mut MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_in_parens(&mut **self, node, __ast_path)
+    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
+        <V as VisitMut>::visit_mut_media_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_not(&mut **self, node, __ast_path)
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
+        <V as VisitMut>::visit_mut_media_not(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_or(&mut **self, node, __ast_path)
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
+        <V as VisitMut>::visit_mut_media_or(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_query(&mut **self, node, __ast_path)
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
+        <V as VisitMut>::visit_mut_media_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_query_list(
-        &mut self,
-        node: &mut MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_query_list(&mut **self, node, __ast_path)
+    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
+        <V as VisitMut>::visit_mut_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_querys(&mut **self, node, __ast_path)
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
+        <V as VisitMut>::visit_mut_media_querys(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_type(&mut **self, node, __ast_path)
+    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
+        <V as VisitMut>::visit_mut_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_named_namespace(
-        &mut self,
-        node: &mut NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_named_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
+        <V as VisitMut>::visit_mut_named_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
+        <V as VisitMut>::visit_mut_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(
-        &mut self,
-        node: &mut NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prefix(&mut **self, node, __ast_path)
+    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
+        <V as VisitMut>::visit_mut_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(
-        &mut self,
-        node: &mut NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
+        <V as VisitMut>::visit_mut_namespace_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(
-        &mut self,
-        node: &mut NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(&mut **self, node, __ast_path)
+    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
+        <V as VisitMut>::visit_mut_namespace_prelude_uri(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(
-        &mut self,
-        node: &mut NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_nesting_selector(&mut **self, node, __ast_path)
+    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
+        <V as VisitMut>::visit_mut_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
+    fn visit_mut_number(&mut self, node: &mut Number) {
+        <V as VisitMut>::visit_mut_number(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number_type(&mut **self, node, __ast_path)
+    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
+        <V as VisitMut>::visit_mut_number_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(
-        &mut self,
-        node: &mut Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
+        <V as VisitMut>::visit_mut_opt_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
         node: &mut Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
         node: &mut Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_attribute_selector_value(
         &mut self,
         node: &mut Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(
-        &mut self,
-        node: &mut Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_combinator(&mut **self, node, __ast_path)
+    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
+        <V as VisitMut>::visit_mut_opt_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(
-        &mut self,
-        node: &mut Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_container_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
+        <V as VisitMut>::visit_mut_opt_container_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(
-        &mut self,
-        node: &mut Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
+        <V as VisitMut>::visit_mut_opt_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_function(
-        &mut self,
-        node: &mut Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_function(&mut **self, node, __ast_path)
+    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
+        <V as VisitMut>::visit_mut_opt_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(
-        &mut self,
-        node: &mut Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_import_conditions(&mut **self, node, __ast_path)
+    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
+        <V as VisitMut>::visit_mut_opt_import_conditions(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(
-        &mut self,
-        node: &mut Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
+        <V as VisitMut>::visit_mut_opt_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(
-        &mut self,
-        node: &mut Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_important_flag(&mut **self, node, __ast_path)
+    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
+        <V as VisitMut>::visit_mut_opt_important_flag(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(
-        &mut self,
-        node: &mut Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
+        <V as VisitMut>::visit_mut_opt_media_condition_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(
-        &mut self,
-        node: &mut Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_query_list(&mut **self, node, __ast_path)
+    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
+        <V as VisitMut>::visit_mut_opt_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(
-        &mut self,
-        node: &mut Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
+        <V as VisitMut>::visit_mut_opt_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(
-        &mut self,
-        node: &mut Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
+        <V as VisitMut>::visit_mut_opt_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(
-        &mut self,
-        node: &mut Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(&mut **self, node, __ast_path)
+    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
+        <V as VisitMut>::visit_mut_opt_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(
-        &mut self,
-        node: &mut Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(&mut **self, node, __ast_path)
+    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
+        <V as VisitMut>::visit_mut_opt_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_number(&mut **self, node, __ast_path)
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
+        <V as VisitMut>::visit_mut_opt_number(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(
-        &mut self,
-        node: &mut Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(&mut **self, node, __ast_path)
+    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
+        <V as VisitMut>::visit_mut_opt_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(
-        &mut self,
-        node: &mut Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
+        <V as VisitMut>::visit_mut_opt_page_selector_type(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_pseudo_class_selector_childrens(
-        &mut self,
-        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        &mut self,
+        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+    ) {
+        <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(
-        &mut self,
-        node: &mut Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_simple_block(&mut **self, node, __ast_path)
+    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
+        <V as VisitMut>::visit_mut_opt_simple_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(
-        &mut self,
-        node: &mut Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_type_selector(&mut **self, node, __ast_path)
+    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
+        <V as VisitMut>::visit_mut_opt_type_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(
-        &mut self,
-        node: &mut Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(&mut **self, node, __ast_path)
+    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
+        <V as VisitMut>::visit_mut_opt_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(
-        &mut self,
-        node: &mut Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_url_value(&mut **self, node, __ast_path)
+    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
+        <V as VisitMut>::visit_mut_opt_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selector(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
+        <V as VisitMut>::visit_mut_page_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_list(
-        &mut self,
-        node: &mut PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
+        <V as VisitMut>::visit_mut_page_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(
-        &mut self,
-        node: &mut PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
+        <V as VisitMut>::visit_mut_page_selector_pseudo(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(
-        &mut self,
-        node: &mut Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
+        <V as VisitMut>::visit_mut_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(
-        &mut self,
-        node: &mut PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_type(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
+        <V as VisitMut>::visit_mut_page_selector_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selectors(
-        &mut self,
-        node: &mut Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
+        <V as VisitMut>::visit_mut_page_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
+        <V as VisitMut>::visit_mut_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(
-        &mut self,
-        node: &mut PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(&mut **self, node, __ast_path)
+    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
+        <V as VisitMut>::visit_mut_pseudo_class_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(
-        &mut self,
-        node: &mut PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
+        <V as VisitMut>::visit_mut_pseudo_class_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(
-        &mut self,
-        node: &mut PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(&mut **self, node, __ast_path)
+    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
+        <V as VisitMut>::visit_mut_pseudo_element_selector(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_pseudo_element_selector_children(
         &mut self,
         node: &mut PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_pseudo_element_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_qualified_rule(&mut **self, node, __ast_path)
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
+        <V as VisitMut>::visit_mut_qualified_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule_prelude(
-        &mut self,
-        node: &mut QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
+        <V as VisitMut>::visit_mut_qualified_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(
-        &mut self,
-        node: &mut QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_query_in_parens(&mut **self, node, __ast_path)
+    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
+        <V as VisitMut>::visit_mut_query_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ratio(&mut **self, node, __ast_path)
+    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
+        <V as VisitMut>::visit_mut_ratio(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_relative_selector(
-        &mut self,
-        node: &mut RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_relative_selector(&mut **self, node, __ast_path)
+    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
+        <V as VisitMut>::visit_mut_relative_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(
-        &mut self,
-        node: &mut RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_relative_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
+        <V as VisitMut>::visit_mut_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(
-        &mut self,
-        node: &mut Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_relative_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
+        <V as VisitMut>::visit_mut_relative_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_resolution(&mut **self, node, __ast_path)
+    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
+        <V as VisitMut>::visit_mut_resolution(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rule(&mut **self, node, __ast_path)
+    fn visit_mut_rule(&mut self, node: &mut Rule) {
+        <V as VisitMut>::visit_mut_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rules(&mut **self, node, __ast_path)
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
+        <V as VisitMut>::visit_mut_rules(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_scope_range(&mut **self, node, __ast_path)
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
+        <V as VisitMut>::visit_mut_scope_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
+        <V as VisitMut>::visit_mut_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(
-        &mut self,
-        node: &mut SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(&mut **self, node, __ast_path)
+    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
+        <V as VisitMut>::visit_mut_sequence_of_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_simple_block(&mut **self, node, __ast_path)
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
+        <V as VisitMut>::visit_mut_simple_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
+        <V as VisitMut>::visit_mut_size_feature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(
-        &mut self,
-        node: &mut SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_boolean(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
+        <V as VisitMut>::visit_mut_size_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(
-        &mut self,
-        node: &mut SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_name(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
+        <V as VisitMut>::visit_mut_size_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(
-        &mut self,
-        node: &mut SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_plain(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
+        <V as VisitMut>::visit_mut_size_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(
-        &mut self,
-        node: &mut SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
+        <V as VisitMut>::visit_mut_size_feature_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(
-        &mut self,
-        node: &mut SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
+        <V as VisitMut>::visit_mut_size_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(
-        &mut self,
-        node: &mut SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
+        <V as VisitMut>::visit_mut_size_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(
-        &mut self,
-        node: &mut SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_value(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
+        <V as VisitMut>::visit_mut_size_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+        <V as VisitMut>::visit_mut_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
+    fn visit_mut_str(&mut self, node: &mut Str) {
+        <V as VisitMut>::visit_mut_str(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_style_block(&mut **self, node, __ast_path)
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
+        <V as VisitMut>::visit_mut_style_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stylesheet(&mut **self, node, __ast_path)
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
+        <V as VisitMut>::visit_mut_stylesheet(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(
-        &mut self,
-        node: &mut SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_subclass_selector(&mut **self, node, __ast_path)
+    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
+        <V as VisitMut>::visit_mut_subclass_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(
-        &mut self,
-        node: &mut Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_subclass_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
+        <V as VisitMut>::visit_mut_subclass_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_and(&mut **self, node, __ast_path)
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
+        <V as VisitMut>::visit_mut_supports_and(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_condition(
-        &mut self,
-        node: &mut SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition(&mut **self, node, __ast_path)
+    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
+        <V as VisitMut>::visit_mut_supports_condition(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(
-        &mut self,
-        node: &mut SupportsConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition_type(&mut **self, node, __ast_path)
+    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
+        <V as VisitMut>::visit_mut_supports_condition_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(
-        &mut self,
-        node: &mut Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition_types(&mut **self, node, __ast_path)
+    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
+        <V as VisitMut>::visit_mut_supports_condition_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_feature(
-        &mut self,
-        node: &mut SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_feature(&mut **self, node, __ast_path)
+    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
+        <V as VisitMut>::visit_mut_supports_feature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(
-        &mut self,
-        node: &mut SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_in_parens(&mut **self, node, __ast_path)
+    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
+        <V as VisitMut>::visit_mut_supports_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_not(&mut **self, node, __ast_path)
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
+        <V as VisitMut>::visit_mut_supports_not(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_or(&mut **self, node, __ast_path)
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
+        <V as VisitMut>::visit_mut_supports_or(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(
-        &mut self,
-        node: &mut TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_tag_name_selector(&mut **self, node, __ast_path)
+    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
+        <V as VisitMut>::visit_mut_tag_name_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_time(&mut **self, node, __ast_path)
+    fn visit_mut_time(&mut self, node: &mut Time) {
+        <V as VisitMut>::visit_mut_time(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_time_percentage(
-        &mut self,
-        node: &mut TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_time_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
+        <V as VisitMut>::visit_mut_time_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_token(&mut **self, node, __ast_path)
+    fn visit_mut_token(&mut self, node: &mut Token) {
+        <V as VisitMut>::visit_mut_token(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_token_and_span(&mut **self, node, __ast_path)
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
+        <V as VisitMut>::visit_mut_token_and_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_type_selector(&mut **self, node, __ast_path)
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
+        <V as VisitMut>::visit_mut_type_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unicode_range(&mut **self, node, __ast_path)
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
+        <V as VisitMut>::visit_mut_unicode_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_universal_selector(
-        &mut self,
-        node: &mut UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_universal_selector(&mut **self, node, __ast_path)
+    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
+        <V as VisitMut>::visit_mut_universal_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(
-        &mut self,
-        node: &mut UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_unknown_dimension(&mut **self, node, __ast_path)
+    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
+        <V as VisitMut>::visit_mut_unknown_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url(&mut **self, node, __ast_path)
+    fn visit_mut_url(&mut self, node: &mut Url) {
+        <V as VisitMut>::visit_mut_url(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_key_value(&mut **self, node, __ast_path)
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
+        <V as VisitMut>::visit_mut_url_key_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_modifier(&mut **self, node, __ast_path)
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
+        <V as VisitMut>::visit_mut_url_modifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(
-        &mut self,
-        node: &mut Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_url_modifiers(&mut **self, node, __ast_path)
+    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
+        <V as VisitMut>::visit_mut_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_value(&mut **self, node, __ast_path)
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
+        <V as VisitMut>::visit_mut_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_value_raw(&mut **self, node, __ast_path)
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
+        <V as VisitMut>::visit_mut_url_value_raw(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_wq_name(&mut **self, node, __ast_path)
+    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
+        <V as VisitMut>::visit_mut_wq_name(&mut **self, node)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitMutAstPath for Box<V>
+impl<V> VisitMut for Box<V>
 where
-    V: ?Sized + VisitMutAstPath,
+    V: ?Sized + VisitMut,
 {
     #[inline]
-    fn visit_mut_absolute_color_base(
-        &mut self,
-        node: &mut AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_absolute_color_base(&mut **self, node, __ast_path)
+    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
+        <V as VisitMut>::visit_mut_absolute_color_base(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_alpha_value(&mut **self, node, __ast_path)
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
+        <V as VisitMut>::visit_mut_alpha_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_an_plus_b(&mut **self, node, __ast_path)
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
+        <V as VisitMut>::visit_mut_an_plus_b(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(
-        &mut self,
-        node: &mut AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(&mut **self, node, __ast_path)
+    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
+        <V as VisitMut>::visit_mut_an_plus_b_notation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_angle(&mut **self, node, __ast_path)
+    fn visit_mut_angle(&mut self, node: &mut Angle) {
+        <V as VisitMut>::visit_mut_angle(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(
-        &mut self,
-        node: &mut AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_angle_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
+        <V as VisitMut>::visit_mut_angle_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_any_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
+        <V as VisitMut>::visit_mut_any_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_at_rule(&mut **self, node, __ast_path)
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
+        <V as VisitMut>::visit_mut_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_at_rule_name(&mut **self, node, __ast_path)
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
+        <V as VisitMut>::visit_mut_at_rule_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(
-        &mut self,
-        node: &mut AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_at_rule_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
+        <V as VisitMut>::visit_mut_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+        <V as VisitMut>::visit_mut_atom(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(
-        &mut self,
-        node: &mut AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
+        <V as VisitMut>::visit_mut_attribute_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(
-        &mut self,
-        node: &mut AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
+        <V as VisitMut>::visit_mut_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_attribute_selector_matcher_value(
         &mut self,
         node: &mut AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_attribute_selector_matcher_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(
-        &mut self,
-        node: &mut AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
+        <V as VisitMut>::visit_mut_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(
-        &mut self,
-        node: &mut AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_value(&mut **self, node, __ast_path)
+    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
+        <V as VisitMut>::visit_mut_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bin_op(&mut **self, node, __ast_path)
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
+        <V as VisitMut>::visit_mut_bin_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_operator(&mut **self, node, __ast_path)
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
+        <V as VisitMut>::visit_mut_calc_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(
-        &mut self,
-        node: &mut CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_operator_type(&mut **self, node, __ast_path)
+    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
+        <V as VisitMut>::visit_mut_calc_operator_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_product(&mut **self, node, __ast_path)
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
+        <V as VisitMut>::visit_mut_calc_product(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(
-        &mut self,
-        node: &mut CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(&mut **self, node, __ast_path)
+    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
+        <V as VisitMut>::visit_mut_calc_product_or_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(
-        &mut self,
-        node: &mut Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(&mut **self, node, __ast_path)
+    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
+        <V as VisitMut>::visit_mut_calc_product_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_sum(&mut **self, node, __ast_path)
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
+        <V as VisitMut>::visit_mut_calc_sum(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_value(&mut **self, node, __ast_path)
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
+        <V as VisitMut>::visit_mut_calc_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(
-        &mut self,
-        node: &mut CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(&mut **self, node, __ast_path)
+    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
+        <V as VisitMut>::visit_mut_calc_value_or_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(
-        &mut self,
-        node: &mut Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(&mut **self, node, __ast_path)
+    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
+        <V as VisitMut>::visit_mut_calc_value_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_selector(&mut **self, node, __ast_path)
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
+        <V as VisitMut>::visit_mut_class_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_cmyk_component(&mut **self, node, __ast_path)
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
+        <V as VisitMut>::visit_mut_cmyk_component(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_color(&mut **self, node, __ast_path)
+    fn visit_mut_color(&mut self, node: &mut Color) {
+        <V as VisitMut>::visit_mut_color(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(
-        &mut self,
-        node: &mut ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_color_profile_name(&mut **self, node, __ast_path)
+    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
+        <V as VisitMut>::visit_mut_color_profile_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_combinator(&mut **self, node, __ast_path)
+    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
+        <V as VisitMut>::visit_mut_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_combinator_value(
-        &mut self,
-        node: &mut CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_combinator_value(&mut **self, node, __ast_path)
+    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
+        <V as VisitMut>::visit_mut_combinator_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selector(
-        &mut self,
-        node: &mut ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
+        <V as VisitMut>::visit_mut_complex_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(
-        &mut self,
-        node: &mut ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector_children(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
+        <V as VisitMut>::visit_mut_complex_selector_children(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(
-        &mut self,
-        node: &mut Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
+        <V as VisitMut>::visit_mut_complex_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(
-        &mut self,
-        node: &mut Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_complex_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
+        <V as VisitMut>::visit_mut_complex_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_component_value(
-        &mut self,
-        node: &mut ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_component_value(&mut **self, node, __ast_path)
+    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
+        <V as VisitMut>::visit_mut_component_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_component_values(
-        &mut self,
-        node: &mut Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_component_values(&mut **self, node, __ast_path)
+    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
+        <V as VisitMut>::visit_mut_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_compound_selector(
-        &mut self,
-        node: &mut CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_compound_selector(&mut **self, node, __ast_path)
+    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
+        <V as VisitMut>::visit_mut_compound_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(
-        &mut self,
-        node: &mut CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_compound_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
+        <V as VisitMut>::visit_mut_compound_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(
-        &mut self,
-        node: &mut Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_compound_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
+        <V as VisitMut>::visit_mut_compound_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_condition(
-        &mut self,
-        node: &mut ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_condition(&mut **self, node, __ast_path)
+    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
+        <V as VisitMut>::visit_mut_container_condition(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_name(&mut **self, node, __ast_path)
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
+        <V as VisitMut>::visit_mut_container_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query(
-        &mut self,
-        node: &mut ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query(&mut **self, node, __ast_path)
+    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
+        <V as VisitMut>::visit_mut_container_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_and(
-        &mut self,
-        node: &mut ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_and(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
+        <V as VisitMut>::visit_mut_container_query_and(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_not(
-        &mut self,
-        node: &mut ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_not(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
+        <V as VisitMut>::visit_mut_container_query_not(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_or(
-        &mut self,
-        node: &mut ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_or(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
+        <V as VisitMut>::visit_mut_container_query_or(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_type(
-        &mut self,
-        node: &mut ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_type(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
+        <V as VisitMut>::visit_mut_container_query_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_container_query_types(
-        &mut self,
-        node: &mut Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_container_query_types(&mut **self, node, __ast_path)
+    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
+        <V as VisitMut>::visit_mut_container_query_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(
-        &mut self,
-        node: &mut CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_highlight_name(&mut **self, node, __ast_path)
+    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
+        <V as VisitMut>::visit_mut_custom_highlight_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_ident(&mut **self, node, __ast_path)
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
+        <V as VisitMut>::visit_mut_custom_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_idents(
-        &mut self,
-        node: &mut Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_idents(&mut **self, node, __ast_path)
+    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
+        <V as VisitMut>::visit_mut_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(
-        &mut self,
-        node: &mut CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_media_query(&mut **self, node, __ast_path)
+    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
+        <V as VisitMut>::visit_mut_custom_media_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(
-        &mut self,
-        node: &mut CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
+        <V as VisitMut>::visit_mut_custom_media_query_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(
-        &mut self,
-        node: &mut CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_custom_property_name(&mut **self, node, __ast_path)
+    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
+        <V as VisitMut>::visit_mut_custom_property_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_dashed_ident(&mut **self, node, __ast_path)
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
+        <V as VisitMut>::visit_mut_dashed_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_declaration(&mut **self, node, __ast_path)
+    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
+        <V as VisitMut>::visit_mut_declaration(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_declaration_name(
-        &mut self,
-        node: &mut DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_declaration_name(&mut **self, node, __ast_path)
+    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
+        <V as VisitMut>::visit_mut_declaration_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(
-        &mut self,
-        node: &mut DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(&mut **self, node, __ast_path)
+    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
+        <V as VisitMut>::visit_mut_declaration_or_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_delimiter(&mut **self, node, __ast_path)
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
+        <V as VisitMut>::visit_mut_delimiter(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(
-        &mut self,
-        node: &mut DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_delimiter_value(&mut **self, node, __ast_path)
+    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
+        <V as VisitMut>::visit_mut_delimiter_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_dimension(&mut **self, node, __ast_path)
+    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
+        <V as VisitMut>::visit_mut_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_dimension_token(
-        &mut self,
-        node: &mut DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_dimension_token(&mut **self, node, __ast_path)
+    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
+        <V as VisitMut>::visit_mut_dimension_token(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_document_prelude(
-        &mut self,
-        node: &mut DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
+        <V as VisitMut>::visit_mut_document_prelude(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_document_prelude_matching_function(
         &mut self,
         node: &mut DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_document_prelude_matching_function(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_document_prelude_matching_functions(
         &mut self,
         node: &mut Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_document_prelude_matching_functions(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_extension_name(&mut **self, node, __ast_path)
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
+        <V as VisitMut>::visit_mut_extension_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_family_name(&mut **self, node, __ast_path)
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
+        <V as VisitMut>::visit_mut_family_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_family_names(&mut **self, node, __ast_path)
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
+        <V as VisitMut>::visit_mut_family_names(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_flex(&mut **self, node, __ast_path)
+    fn visit_mut_flex(&mut self, node: &mut Flex) {
+        <V as VisitMut>::visit_mut_flex(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(
-        &mut self,
-        node: &mut FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
+        <V as VisitMut>::visit_mut_font_feature_values_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(
-        &mut self,
-        node: &mut ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
+        <V as VisitMut>::visit_mut_forgiving_complex_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(
-        &mut self,
-        node: &mut Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
+        <V as VisitMut>::visit_mut_forgiving_complex_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(
-        &mut self,
-        node: &mut ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
+        <V as VisitMut>::visit_mut_forgiving_relative_selector(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_forgiving_relative_selector_list(
         &mut self,
         node: &mut ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_forgiving_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_forgiving_relative_selectors(
         &mut self,
         node: &mut Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(
-            &mut **self,
-            node,
-            __ast_path,
-        )
-    }
-
-    #[inline]
-    fn visit_mut_forgiving_selector_list(
-        &mut self,
-        node: &mut ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(&mut **self, node, __ast_path)
+        <V as VisitMut>::visit_mut_forgiving_relative_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_frequency(&mut **self, node, __ast_path)
+    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
+        <V as VisitMut>::visit_mut_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(
-        &mut self,
-        node: &mut FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_frequency_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
+        <V as VisitMut>::visit_mut_frequency(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
+    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
+        <V as VisitMut>::visit_mut_frequency_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function_name(&mut **self, node, __ast_path)
+    fn visit_mut_function(&mut self, node: &mut Function) {
+        <V as VisitMut>::visit_mut_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(
-        &mut self,
-        node: &mut GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_general_enclosed(&mut **self, node, __ast_path)
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
+        <V as VisitMut>::visit_mut_function_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_hex_color(&mut **self, node, __ast_path)
+    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
+        <V as VisitMut>::visit_mut_general_enclosed(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_hue(&mut **self, node, __ast_path)
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
+        <V as VisitMut>::visit_mut_hex_color(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_id_selector(&mut **self, node, __ast_path)
+    fn visit_mut_hue(&mut self, node: &mut Hue) {
+        <V as VisitMut>::visit_mut_hue(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
+        <V as VisitMut>::visit_mut_id_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_idents(&mut **self, node, __ast_path)
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
+        <V as VisitMut>::visit_mut_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_conditions(
-        &mut self,
-        node: &mut ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_conditions(&mut **self, node, __ast_path)
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
+        <V as VisitMut>::visit_mut_idents(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_href(&mut **self, node, __ast_path)
+    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
+        <V as VisitMut>::visit_mut_import_conditions(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(
-        &mut self,
-        node: &mut ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_layer_name(&mut **self, node, __ast_path)
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
+        <V as VisitMut>::visit_mut_import_href(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
+        <V as VisitMut>::visit_mut_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_important_flag(&mut **self, node, __ast_path)
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
+        <V as VisitMut>::visit_mut_import_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_integer(&mut **self, node, __ast_path)
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
+        <V as VisitMut>::visit_mut_important_flag(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_block(&mut **self, node, __ast_path)
+    fn visit_mut_integer(&mut self, node: &mut Integer) {
+        <V as VisitMut>::visit_mut_integer(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(
-        &mut self,
-        node: &mut KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_selector(&mut **self, node, __ast_path)
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
+        <V as VisitMut>::visit_mut_keyframe_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(
-        &mut self,
-        node: &mut Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
+        <V as VisitMut>::visit_mut_keyframe_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_name(&mut **self, node, __ast_path)
+    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
+        <V as VisitMut>::visit_mut_keyframe_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(
-        &mut self,
-        node: &mut KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(&mut **self, node, __ast_path)
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
+        <V as VisitMut>::visit_mut_keyframes_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(
-        &mut self,
-        node: &mut KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
+    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
+        <V as VisitMut>::visit_mut_keyframes_pseudo_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_name(&mut **self, node, __ast_path)
+    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
+        <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(
-        &mut self,
-        node: &mut LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_layer_name_list(&mut **self, node, __ast_path)
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
+        <V as VisitMut>::visit_mut_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_names(&mut **self, node, __ast_path)
+    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
+        <V as VisitMut>::visit_mut_layer_name_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
+        <V as VisitMut>::visit_mut_layer_names(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_length(&mut **self, node, __ast_path)
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
+        <V as VisitMut>::visit_mut_layer_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_length_percentage(
-        &mut self,
-        node: &mut LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_length_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_length(&mut self, node: &mut Length) {
+        <V as VisitMut>::visit_mut_length(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(
-        &mut self,
-        node: &mut ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_list_of_component_values(&mut **self, node, __ast_path)
+    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
+        <V as VisitMut>::visit_mut_length_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_and(&mut **self, node, __ast_path)
+    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
+        <V as VisitMut>::visit_mut_list_of_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition(
-        &mut self,
-        node: &mut MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition(&mut **self, node, __ast_path)
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
+        <V as VisitMut>::visit_mut_media_and(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(
-        &mut self,
-        node: &mut MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_all_type(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
+        <V as VisitMut>::visit_mut_media_condition(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(
-        &mut self,
-        node: &mut Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_all_types(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
+        <V as VisitMut>::visit_mut_media_condition_all_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(
-        &mut self,
-        node: &mut MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_type(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
+        <V as VisitMut>::visit_mut_media_condition_all_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(
-        &mut self,
-        node: &mut MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or(&mut **self, node, __ast_path)
+    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
+        <V as VisitMut>::visit_mut_media_condition_type(&mut **self, node)
+    }
+
+    #[inline]
+    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
+        <V as VisitMut>::visit_mut_media_condition_without_or(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_media_condition_without_or_type(
         &mut self,
         node: &mut MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_media_condition_without_or_type(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_media_condition_without_or_types(
         &mut self,
         node: &mut Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_media_condition_without_or_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
+        <V as VisitMut>::visit_mut_media_feature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_boolean(
-        &mut self,
-        node: &mut MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_boolean(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
+        <V as VisitMut>::visit_mut_media_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(
-        &mut self,
-        node: &mut MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_name(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
+        <V as VisitMut>::visit_mut_media_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(
-        &mut self,
-        node: &mut MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_plain(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
+        <V as VisitMut>::visit_mut_media_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(
-        &mut self,
-        node: &mut MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
+        <V as VisitMut>::visit_mut_media_feature_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(
-        &mut self,
-        node: &mut MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
+        <V as VisitMut>::visit_mut_media_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(
-        &mut self,
-        node: &mut MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
+        <V as VisitMut>::visit_mut_media_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(
-        &mut self,
-        node: &mut MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_value(&mut **self, node, __ast_path)
+    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
+        <V as VisitMut>::visit_mut_media_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(
-        &mut self,
-        node: &mut MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_in_parens(&mut **self, node, __ast_path)
+    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
+        <V as VisitMut>::visit_mut_media_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_not(&mut **self, node, __ast_path)
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
+        <V as VisitMut>::visit_mut_media_not(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_or(&mut **self, node, __ast_path)
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
+        <V as VisitMut>::visit_mut_media_or(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_query(&mut **self, node, __ast_path)
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
+        <V as VisitMut>::visit_mut_media_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_query_list(
-        &mut self,
-        node: &mut MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_media_query_list(&mut **self, node, __ast_path)
+    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
+        <V as VisitMut>::visit_mut_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_querys(&mut **self, node, __ast_path)
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
+        <V as VisitMut>::visit_mut_media_querys(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_type(&mut **self, node, __ast_path)
+    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
+        <V as VisitMut>::visit_mut_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_named_namespace(
-        &mut self,
-        node: &mut NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_named_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
+        <V as VisitMut>::visit_mut_named_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
+        <V as VisitMut>::visit_mut_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(
-        &mut self,
-        node: &mut NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prefix(&mut **self, node, __ast_path)
+    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
+        <V as VisitMut>::visit_mut_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(
-        &mut self,
-        node: &mut NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
+        <V as VisitMut>::visit_mut_namespace_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(
-        &mut self,
-        node: &mut NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(&mut **self, node, __ast_path)
+    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
+        <V as VisitMut>::visit_mut_namespace_prelude_uri(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(
-        &mut self,
-        node: &mut NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_nesting_selector(&mut **self, node, __ast_path)
+    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
+        <V as VisitMut>::visit_mut_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
+    fn visit_mut_number(&mut self, node: &mut Number) {
+        <V as VisitMut>::visit_mut_number(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number_type(&mut **self, node, __ast_path)
+    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
+        <V as VisitMut>::visit_mut_number_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(
-        &mut self,
-        node: &mut Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
+        <V as VisitMut>::visit_mut_opt_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
         node: &mut Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
         node: &mut Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_attribute_selector_value(
         &mut self,
         node: &mut Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(
-        &mut self,
-        node: &mut Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_combinator(&mut **self, node, __ast_path)
+    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
+        <V as VisitMut>::visit_mut_opt_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(
-        &mut self,
-        node: &mut Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_container_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
+        <V as VisitMut>::visit_mut_opt_container_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(
-        &mut self,
-        node: &mut Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
+        <V as VisitMut>::visit_mut_opt_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_function(
-        &mut self,
-        node: &mut Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_function(&mut **self, node, __ast_path)
+    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
+        <V as VisitMut>::visit_mut_opt_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(
-        &mut self,
-        node: &mut Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_import_conditions(&mut **self, node, __ast_path)
+    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
+        <V as VisitMut>::visit_mut_opt_import_conditions(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(
-        &mut self,
-        node: &mut Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
+        <V as VisitMut>::visit_mut_opt_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(
-        &mut self,
-        node: &mut Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_important_flag(&mut **self, node, __ast_path)
+    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
+        <V as VisitMut>::visit_mut_opt_important_flag(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(
-        &mut self,
-        node: &mut Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
+        <V as VisitMut>::visit_mut_opt_media_condition_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(
-        &mut self,
-        node: &mut Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_query_list(&mut **self, node, __ast_path)
+    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
+        <V as VisitMut>::visit_mut_opt_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(
-        &mut self,
-        node: &mut Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
+        <V as VisitMut>::visit_mut_opt_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(
-        &mut self,
-        node: &mut Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_namespace(&mut **self, node, __ast_path)
+    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
+        <V as VisitMut>::visit_mut_opt_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(
-        &mut self,
-        node: &mut Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(&mut **self, node, __ast_path)
+    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
+        <V as VisitMut>::visit_mut_opt_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(
-        &mut self,
-        node: &mut Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(&mut **self, node, __ast_path)
+    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
+        <V as VisitMut>::visit_mut_opt_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_number(&mut **self, node, __ast_path)
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
+        <V as VisitMut>::visit_mut_opt_number(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(
-        &mut self,
-        node: &mut Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(&mut **self, node, __ast_path)
+    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
+        <V as VisitMut>::visit_mut_opt_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(
-        &mut self,
-        node: &mut Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
+        <V as VisitMut>::visit_mut_opt_page_selector_type(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(
-        &mut self,
-        node: &mut Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_simple_block(&mut **self, node, __ast_path)
+    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
+        <V as VisitMut>::visit_mut_opt_simple_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(
-        &mut self,
-        node: &mut Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_type_selector(&mut **self, node, __ast_path)
+    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
+        <V as VisitMut>::visit_mut_opt_type_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(
-        &mut self,
-        node: &mut Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(&mut **self, node, __ast_path)
+    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
+        <V as VisitMut>::visit_mut_opt_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(
-        &mut self,
-        node: &mut Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_url_value(&mut **self, node, __ast_path)
+    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
+        <V as VisitMut>::visit_mut_opt_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selector(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
+        <V as VisitMut>::visit_mut_page_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_list(
-        &mut self,
-        node: &mut PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
+        <V as VisitMut>::visit_mut_page_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(
-        &mut self,
-        node: &mut PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
+        <V as VisitMut>::visit_mut_page_selector_pseudo(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(
-        &mut self,
-        node: &mut Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
+        <V as VisitMut>::visit_mut_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(
-        &mut self,
-        node: &mut PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_type(&mut **self, node, __ast_path)
+    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
+        <V as VisitMut>::visit_mut_page_selector_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_page_selectors(
-        &mut self,
-        node: &mut Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_page_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
+        <V as VisitMut>::visit_mut_page_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
+        <V as VisitMut>::visit_mut_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(
-        &mut self,
-        node: &mut PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(&mut **self, node, __ast_path)
+    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
+        <V as VisitMut>::visit_mut_pseudo_class_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(
-        &mut self,
-        node: &mut PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
+        <V as VisitMut>::visit_mut_pseudo_class_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(
-        &mut self,
-        node: &mut PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(&mut **self, node, __ast_path)
+    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
+        <V as VisitMut>::visit_mut_pseudo_element_selector(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_pseudo_element_selector_children(
         &mut self,
         node: &mut PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_pseudo_element_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_qualified_rule(&mut **self, node, __ast_path)
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
+        <V as VisitMut>::visit_mut_qualified_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_qualified_rule_prelude(
-        &mut self,
-        node: &mut QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(&mut **self, node, __ast_path)
+    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
+        <V as VisitMut>::visit_mut_qualified_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(
-        &mut self,
-        node: &mut QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_query_in_parens(&mut **self, node, __ast_path)
+    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
+        <V as VisitMut>::visit_mut_query_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ratio(&mut **self, node, __ast_path)
+    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
+        <V as VisitMut>::visit_mut_ratio(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_relative_selector(
-        &mut self,
-        node: &mut RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_relative_selector(&mut **self, node, __ast_path)
+    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
+        <V as VisitMut>::visit_mut_relative_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(
-        &mut self,
-        node: &mut RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_relative_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
+        <V as VisitMut>::visit_mut_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(
-        &mut self,
-        node: &mut Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_relative_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
+        <V as VisitMut>::visit_mut_relative_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_resolution(&mut **self, node, __ast_path)
+    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
+        <V as VisitMut>::visit_mut_resolution(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rule(&mut **self, node, __ast_path)
+    fn visit_mut_rule(&mut self, node: &mut Rule) {
+        <V as VisitMut>::visit_mut_rule(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rules(&mut **self, node, __ast_path)
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
+        <V as VisitMut>::visit_mut_rules(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_scope_range(&mut **self, node, __ast_path)
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
+        <V as VisitMut>::visit_mut_scope_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_selector_list(&mut **self, node, __ast_path)
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
+        <V as VisitMut>::visit_mut_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(
-        &mut self,
-        node: &mut SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(&mut **self, node, __ast_path)
+    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
+        <V as VisitMut>::visit_mut_sequence_of_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_simple_block(&mut **self, node, __ast_path)
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
+        <V as VisitMut>::visit_mut_simple_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
+        <V as VisitMut>::visit_mut_size_feature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(
-        &mut self,
-        node: &mut SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_boolean(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
+        <V as VisitMut>::visit_mut_size_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(
-        &mut self,
-        node: &mut SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_name(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
+        <V as VisitMut>::visit_mut_size_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(
-        &mut self,
-        node: &mut SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_plain(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
+        <V as VisitMut>::visit_mut_size_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(
-        &mut self,
-        node: &mut SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
+        <V as VisitMut>::visit_mut_size_feature_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(
-        &mut self,
-        node: &mut SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
+        <V as VisitMut>::visit_mut_size_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(
-        &mut self,
-        node: &mut SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
+        <V as VisitMut>::visit_mut_size_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(
-        &mut self,
-        node: &mut SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_value(&mut **self, node, __ast_path)
+    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
+        <V as VisitMut>::visit_mut_size_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+        <V as VisitMut>::visit_mut_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
+    fn visit_mut_str(&mut self, node: &mut Str) {
+        <V as VisitMut>::visit_mut_str(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_style_block(&mut **self, node, __ast_path)
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
+        <V as VisitMut>::visit_mut_style_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stylesheet(&mut **self, node, __ast_path)
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
+        <V as VisitMut>::visit_mut_stylesheet(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(
-        &mut self,
-        node: &mut SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_subclass_selector(&mut **self, node, __ast_path)
+    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
+        <V as VisitMut>::visit_mut_subclass_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(
-        &mut self,
-        node: &mut Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_subclass_selectors(&mut **self, node, __ast_path)
+    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
+        <V as VisitMut>::visit_mut_subclass_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_and(&mut **self, node, __ast_path)
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
+        <V as VisitMut>::visit_mut_supports_and(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_condition(
-        &mut self,
-        node: &mut SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition(&mut **self, node, __ast_path)
+    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
+        <V as VisitMut>::visit_mut_supports_condition(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(
-        &mut self,
-        node: &mut SupportsConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition_type(&mut **self, node, __ast_path)
+    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
+        <V as VisitMut>::visit_mut_supports_condition_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(
-        &mut self,
-        node: &mut Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition_types(&mut **self, node, __ast_path)
+    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
+        <V as VisitMut>::visit_mut_supports_condition_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_feature(
-        &mut self,
-        node: &mut SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_feature(&mut **self, node, __ast_path)
+    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
+        <V as VisitMut>::visit_mut_supports_feature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(
-        &mut self,
-        node: &mut SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_supports_in_parens(&mut **self, node, __ast_path)
+    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
+        <V as VisitMut>::visit_mut_supports_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_not(&mut **self, node, __ast_path)
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
+        <V as VisitMut>::visit_mut_supports_not(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_or(&mut **self, node, __ast_path)
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
+        <V as VisitMut>::visit_mut_supports_or(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(
-        &mut self,
-        node: &mut TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_tag_name_selector(&mut **self, node, __ast_path)
+    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
+        <V as VisitMut>::visit_mut_tag_name_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_time(&mut **self, node, __ast_path)
+    fn visit_mut_time(&mut self, node: &mut Time) {
+        <V as VisitMut>::visit_mut_time(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_time_percentage(
-        &mut self,
-        node: &mut TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_time_percentage(&mut **self, node, __ast_path)
+    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
+        <V as VisitMut>::visit_mut_time_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_token(&mut **self, node, __ast_path)
+    fn visit_mut_token(&mut self, node: &mut Token) {
+        <V as VisitMut>::visit_mut_token(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_token_and_span(&mut **self, node, __ast_path)
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
+        <V as VisitMut>::visit_mut_token_and_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_type_selector(&mut **self, node, __ast_path)
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
+        <V as VisitMut>::visit_mut_type_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unicode_range(&mut **self, node, __ast_path)
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
+        <V as VisitMut>::visit_mut_unicode_range(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_universal_selector(
-        &mut self,
-        node: &mut UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_universal_selector(&mut **self, node, __ast_path)
+    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
+        <V as VisitMut>::visit_mut_universal_selector(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(
-        &mut self,
-        node: &mut UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_unknown_dimension(&mut **self, node, __ast_path)
+    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
+        <V as VisitMut>::visit_mut_unknown_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url(&mut **self, node, __ast_path)
+    fn visit_mut_url(&mut self, node: &mut Url) {
+        <V as VisitMut>::visit_mut_url(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_key_value(&mut **self, node, __ast_path)
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
+        <V as VisitMut>::visit_mut_url_key_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_modifier(&mut **self, node, __ast_path)
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
+        <V as VisitMut>::visit_mut_url_modifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(
-        &mut self,
-        node: &mut Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_url_modifiers(&mut **self, node, __ast_path)
+    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
+        <V as VisitMut>::visit_mut_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_value(&mut **self, node, __ast_path)
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
+        <V as VisitMut>::visit_mut_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_value_raw(&mut **self, node, __ast_path)
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
+        <V as VisitMut>::visit_mut_url_value_raw(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_wq_name(&mut **self, node, __ast_path)
+    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
+        <V as VisitMut>::visit_mut_wq_name(&mut **self, node)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<A, B> VisitMutAstPath for ::swc_visit::Either<A, B>
+impl<A, B> VisitMut for ::swc_visit::Either<A, B>
 where
-    A: VisitMutAstPath,
-    B: VisitMutAstPath,
+    A: VisitMut,
+    B: VisitMut,
 {
     #[inline]
-    fn visit_mut_absolute_color_base(
-        &mut self,
-        node: &mut AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_absolute_color_base(visitor, node, __ast_path)
+                VisitMut::visit_mut_absolute_color_base(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_absolute_color_base(visitor, node, __ast_path)
+                VisitMut::visit_mut_absolute_color_base(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_alpha_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_alpha_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_alpha_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_alpha_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_an_plus_b(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_an_plus_b(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_an_plus_b(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_an_plus_b(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(
-        &mut self,
-        node: &mut AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_an_plus_b_notation(visitor, node, __ast_path)
+                VisitMut::visit_mut_an_plus_b_notation(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_an_plus_b_notation(visitor, node, __ast_path)
+                VisitMut::visit_mut_an_plus_b_notation(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
+    fn visit_mut_angle(&mut self, node: &mut Angle) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_angle(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_angle(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_angle(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_angle(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(
-        &mut self,
-        node: &mut AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_angle_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_angle_percentage(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_angle_percentage(visitor, node, __ast_path)
+                VisitMut::visit_mut_angle_percentage(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_any_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_any_namespace(visitor, node, __ast_path)
-            }
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
+        match self {
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_any_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_any_namespace(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_at_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_at_rule(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_at_rule(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_at_rule(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_at_rule_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_at_rule_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_at_rule_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_at_rule_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(
-        &mut self,
-        node: &mut AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_at_rule_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_at_rule_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_at_rule_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_at_rule_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_atom(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(
-        &mut self,
-        node: &mut AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(
-        &mut self,
-        node: &mut AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_matcher(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector_matcher(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_matcher(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector_matcher(visitor, node)
             }
         }
     }
@@ -58469,758 +41671,523 @@ where
     fn visit_mut_attribute_selector_matcher_value(
         &mut self,
         node: &mut AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_matcher_value(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_attribute_selector_matcher_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_matcher_value(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_attribute_selector_matcher_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(
-        &mut self,
-        node: &mut AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_modifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector_modifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_modifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector_modifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(
-        &mut self,
-        node: &mut AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_attribute_selector_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_attribute_selector_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_bin_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_bin_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_bin_op(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_bin_op(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_operator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_operator(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_operator(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(
-        &mut self,
-        node: &mut CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_operator_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_operator_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_operator_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_operator_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_product(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_product(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_product(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_product(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(
-        &mut self,
-        node: &mut CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_product_or_operator(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_product_or_operator(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_product_or_operator(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_product_or_operator(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(
-        &mut self,
-        node: &mut Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_product_or_operators(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_product_or_operators(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_product_or_operators(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_product_or_operators(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_sum(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_sum(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_sum(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_sum(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_calc_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_calc_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(
-        &mut self,
-        node: &mut CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_value_or_operator(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_value_or_operator(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_value_or_operator(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_value_or_operator(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(
-        &mut self,
-        node: &mut Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_calc_value_or_operators(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_value_or_operators(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_calc_value_or_operators(visitor, node, __ast_path)
+                VisitMut::visit_mut_calc_value_or_operators(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_cmyk_component(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_cmyk_component(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_cmyk_component(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_cmyk_component(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
+    fn visit_mut_color(&mut self, node: &mut Color) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_color(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_color(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_color(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_color(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(
-        &mut self,
-        node: &mut ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_color_profile_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_color_profile_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_color_profile_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_color_profile_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_combinator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_combinator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_combinator(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_combinator(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_combinator_value(
-        &mut self,
-        node: &mut CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_combinator_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_combinator_value(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_combinator_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_combinator_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector(
-        &mut self,
-        node: &mut ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_complex_selector(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_complex_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(
-        &mut self,
-        node: &mut ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selector_children(visitor, node, __ast_path)
+                VisitMut::visit_mut_complex_selector_children(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selector_children(visitor, node, __ast_path)
+                VisitMut::visit_mut_complex_selector_children(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(
-        &mut self,
-        node: &mut Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selector_childrens(visitor, node, __ast_path)
+                VisitMut::visit_mut_complex_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selector_childrens(visitor, node, __ast_path)
+                VisitMut::visit_mut_complex_selector_childrens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(
-        &mut self,
-        node: &mut Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_complex_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_complex_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_complex_selectors(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_component_value(
-        &mut self,
-        node: &mut ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_component_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_component_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_component_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_component_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_component_values(
-        &mut self,
-        node: &mut Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_component_values(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_component_values(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_component_values(visitor, node, __ast_path)
+                VisitMut::visit_mut_component_values(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector(
-        &mut self,
-        node: &mut CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_compound_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_compound_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_compound_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_compound_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(
-        &mut self,
-        node: &mut CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_compound_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_compound_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_compound_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_compound_selector_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(
-        &mut self,
-        node: &mut Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_compound_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_compound_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_compound_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_compound_selectors(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_condition(
-        &mut self,
-        node: &mut ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_condition(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_condition(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_condition(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_condition(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_container_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_container_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_container_query(
-        &mut self,
-        node: &mut ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_query(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_container_query(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_container_query(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_and(
-        &mut self,
-        node: &mut ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_and(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_and(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_and(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_and(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_not(
-        &mut self,
-        node: &mut ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_not(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_not(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_not(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_not(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_or(
-        &mut self,
-        node: &mut ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_or(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_or(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_or(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_or(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_type(
-        &mut self,
-        node: &mut ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_types(
-        &mut self,
-        node: &mut Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_types(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_types(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_container_query_types(visitor, node, __ast_path)
+                VisitMut::visit_mut_container_query_types(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(
-        &mut self,
-        node: &mut CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_custom_highlight_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_highlight_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_custom_highlight_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_highlight_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_custom_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_custom_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_custom_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_custom_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_custom_idents(
-        &mut self,
-        node: &mut Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_custom_idents(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_custom_idents(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_custom_idents(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_custom_idents(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(
-        &mut self,
-        node: &mut CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_custom_media_query(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_media_query(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_custom_media_query(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_media_query(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(
-        &mut self,
-        node: &mut CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_custom_media_query_media_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_media_query_media_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_custom_media_query_media_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_media_query_media_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(
-        &mut self,
-        node: &mut CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_custom_property_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_property_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_custom_property_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_custom_property_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_dashed_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_dashed_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_dashed_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_dashed_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
+    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_declaration(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_declaration(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_declaration(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_declaration(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_name(
-        &mut self,
-        node: &mut DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_declaration_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_declaration_name(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_declaration_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_declaration_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(
-        &mut self,
-        node: &mut DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_declaration_or_at_rule(visitor, node, __ast_path)
+                VisitMut::visit_mut_declaration_or_at_rule(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_declaration_or_at_rule(visitor, node, __ast_path)
+                VisitMut::visit_mut_declaration_or_at_rule(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_delimiter(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_delimiter(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_delimiter(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_delimiter(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(
-        &mut self,
-        node: &mut DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_delimiter_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_delimiter_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_delimiter_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_delimiter_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
+    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_dimension(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_dimension(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_dimension(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_dimension(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_dimension_token(
-        &mut self,
-        node: &mut DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_dimension_token(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_dimension_token(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_dimension_token(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_dimension_token(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude(
-        &mut self,
-        node: &mut DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_document_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_document_prelude(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_document_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_document_prelude(visitor, node)
             }
         }
     }
@@ -59229,18 +42196,13 @@ where
     fn visit_mut_document_prelude_matching_function(
         &mut self,
         node: &mut DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_document_prelude_matching_function(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_document_prelude_matching_function(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_document_prelude_matching_function(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_document_prelude_matching_function(visitor, node)
             }
         }
     }
@@ -59249,130 +42211,93 @@ where
     fn visit_mut_document_prelude_matching_functions(
         &mut self,
         node: &mut Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_document_prelude_matching_functions(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_document_prelude_matching_functions(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_document_prelude_matching_functions(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_document_prelude_matching_functions(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_extension_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_extension_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_extension_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_extension_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_family_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_family_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_family_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_family_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_family_names(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_family_names(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_family_names(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_family_names(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
+    fn visit_mut_flex(&mut self, node: &mut Flex) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_flex(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_flex(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_flex(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_flex(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(
-        &mut self,
-        node: &mut FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_font_feature_values_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_font_feature_values_prelude(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_font_feature_values_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_font_feature_values_prelude(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(
-        &mut self,
-        node: &mut ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_complex_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_complex_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_complex_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_complex_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(
-        &mut self,
-        node: &mut Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_complex_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_complex_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_complex_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_complex_selectors(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(
-        &mut self,
-        node: &mut ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_relative_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_relative_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_relative_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_relative_selector(visitor, node)
             }
         }
     }
@@ -59381,18 +42306,13 @@ where
     fn visit_mut_forgiving_relative_selector_list(
         &mut self,
         node: &mut ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_relative_selector_list(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_forgiving_relative_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_relative_selector_list(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_forgiving_relative_selector_list(visitor, node)
             }
         }
     }
@@ -59401,514 +42321,359 @@ where
     fn visit_mut_forgiving_relative_selectors(
         &mut self,
         node: &mut Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_relative_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_relative_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_relative_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_relative_selectors(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_selector_list(
-        &mut self,
-        node: &mut ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_forgiving_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_forgiving_selector_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
+    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_frequency(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_frequency(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_frequency(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_frequency(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(
-        &mut self,
-        node: &mut FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_frequency_percentage(visitor, node, __ast_path)
+                VisitMut::visit_mut_frequency_percentage(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_frequency_percentage(visitor, node, __ast_path)
+                VisitMut::visit_mut_frequency_percentage(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+    fn visit_mut_function(&mut self, node: &mut Function) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_function(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_function(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_function_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_function_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_function_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_function_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(
-        &mut self,
-        node: &mut GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_general_enclosed(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_general_enclosed(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_general_enclosed(visitor, node, __ast_path)
+                VisitMut::visit_mut_general_enclosed(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_hex_color(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_hex_color(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_hex_color(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_hex_color(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_hue(&mut self, node: &mut Hue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_hue(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_hue(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_hue(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_hue(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_id_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_id_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_id_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_id_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_idents(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_idents(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_idents(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_idents(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import_conditions(
-        &mut self,
-        node: &mut ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_conditions(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_conditions(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_conditions(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_conditions(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_href(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_href(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_href(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_href(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(
-        &mut self,
-        node: &mut ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_layer_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_layer_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_layer_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_layer_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_important_flag(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_important_flag(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_important_flag(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_important_flag(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
+    fn visit_mut_integer(&mut self, node: &mut Integer) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_integer(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_integer(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_integer(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_integer(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_keyframe_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_keyframe_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_keyframe_block(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_keyframe_block(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(
-        &mut self,
-        node: &mut KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_keyframe_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframe_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_keyframe_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframe_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(
-        &mut self,
-        node: &mut Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_keyframe_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframe_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_keyframe_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframe_selectors(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_keyframes_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_keyframes_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_keyframes_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_keyframes_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(
-        &mut self,
-        node: &mut KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_keyframes_pseudo_function(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframes_pseudo_function(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_keyframes_pseudo_function(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframes_pseudo_function(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(
-        &mut self,
-        node: &mut KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_keyframes_pseudo_prefix(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframes_pseudo_prefix(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_keyframes_pseudo_prefix(visitor, node, __ast_path)
+                VisitMut::visit_mut_keyframes_pseudo_prefix(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_layer_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_layer_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(
-        &mut self,
-        node: &mut LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_layer_name_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_layer_name_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_name_list(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_name_list(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_layer_names(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_layer_names(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_names(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_names(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_layer_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_layer_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_layer_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_layer_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
+    fn visit_mut_length(&mut self, node: &mut Length) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_length(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_length(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_length(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_length(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_length_percentage(
-        &mut self,
-        node: &mut LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_length_percentage(visitor, node, __ast_path)
+                VisitMut::visit_mut_length_percentage(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_length_percentage(visitor, node, __ast_path)
+                VisitMut::visit_mut_length_percentage(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(
-        &mut self,
-        node: &mut ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_list_of_component_values(visitor, node, __ast_path)
+                VisitMut::visit_mut_list_of_component_values(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_list_of_component_values(visitor, node, __ast_path)
+                VisitMut::visit_mut_list_of_component_values(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_and(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_and(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_and(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition(
-        &mut self,
-        node: &mut MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_condition(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_condition(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(
-        &mut self,
-        node: &mut MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_all_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_all_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_all_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_all_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(
-        &mut self,
-        node: &mut Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_all_types(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_all_types(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_all_types(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_all_types(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(
-        &mut self,
-        node: &mut MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(
-        &mut self,
-        node: &mut MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_without_or(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_without_or(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_without_or(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_condition_without_or(visitor, node)
             }
         }
     }
@@ -59917,18 +42682,13 @@ where
     fn visit_mut_media_condition_without_or_type(
         &mut self,
         node: &mut MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_without_or_type(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_media_condition_without_or_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_without_or_type(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_media_condition_without_or_type(visitor, node)
             }
         }
     }
@@ -59937,383 +42697,260 @@ where
     fn visit_mut_media_condition_without_or_types(
         &mut self,
         node: &mut Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_without_or_types(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_media_condition_without_or_types(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_condition_without_or_types(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_media_condition_without_or_types(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_feature(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_feature(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_boolean(
-        &mut self,
-        node: &mut MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_boolean(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_boolean(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_boolean(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_boolean(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(
-        &mut self,
-        node: &mut MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(
-        &mut self,
-        node: &mut MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_plain(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_plain(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_plain(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_plain(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(
-        &mut self,
-        node: &mut MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_range(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_range(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_range(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_range(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(
-        &mut self,
-        node: &mut MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_range_comparison(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_range_comparison(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_range_comparison(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_range_comparison(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(
-        &mut self,
-        node: &mut MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_range_interval(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_range_interval(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_range_interval(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_range_interval(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(
-        &mut self,
-        node: &mut MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_feature_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_feature_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(
-        &mut self,
-        node: &mut MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_in_parens(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_in_parens(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_in_parens(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_not(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_not(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_not(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_or(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_or(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_or(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_query(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_query(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_query(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_query_list(
-        &mut self,
-        node: &mut MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_query_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_query_list(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_query_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_media_query_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_querys(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_querys(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_querys(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_querys(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_media_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_media_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_media_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_named_namespace(
-        &mut self,
-        node: &mut NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_named_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_named_namespace(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_named_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_named_namespace(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
+    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_namespace(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_namespace(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(
-        &mut self,
-        node: &mut NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_namespace_prefix(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_namespace_prefix(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_namespace_prefix(visitor, node, __ast_path)
+                VisitMut::visit_mut_namespace_prefix(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(
-        &mut self,
-        node: &mut NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_namespace_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_namespace_prelude(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_namespace_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_namespace_prelude(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(
-        &mut self,
-        node: &mut NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_namespace_prelude_uri(visitor, node, __ast_path)
+                VisitMut::visit_mut_namespace_prelude_uri(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_namespace_prelude_uri(visitor, node, __ast_path)
+                VisitMut::visit_mut_namespace_prelude_uri(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(
-        &mut self,
-        node: &mut NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_nesting_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_nesting_selector(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_nesting_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_nesting_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+    fn visit_mut_number(&mut self, node: &mut Number) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_number(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_number(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_number_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_number_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_number_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_number_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(
-        &mut self,
-        node: &mut Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_at_rule_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_at_rule_prelude(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_at_rule_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_at_rule_prelude(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
         }
     }
 
@@ -60321,14 +42958,13 @@ where
     fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
         node: &mut Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_attribute_selector_matcher(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_attribute_selector_matcher(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_attribute_selector_matcher(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_attribute_selector_matcher(visitor, node)
             }
         }
     }
@@ -60337,18 +42973,13 @@ where
     fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
         node: &mut Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_attribute_selector_modifier(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_attribute_selector_modifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_attribute_selector_modifier(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_attribute_selector_modifier(visitor, node)
             }
         }
     }
@@ -60357,278 +42988,193 @@ where
     fn visit_mut_opt_attribute_selector_value(
         &mut self,
         node: &mut Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_attribute_selector_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_attribute_selector_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_attribute_selector_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_attribute_selector_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(
-        &mut self,
-        node: &mut Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_combinator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_combinator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_combinator(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_combinator(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(
-        &mut self,
-        node: &mut Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_container_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_container_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_container_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_container_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(
-        &mut self,
-        node: &mut Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_forgiving_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_forgiving_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_forgiving_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_forgiving_selector_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_function(
-        &mut self,
-        node: &mut Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_function(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_function(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_function(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(
-        &mut self,
-        node: &mut Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_import_conditions(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_import_conditions(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_import_conditions(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_import_conditions(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(
-        &mut self,
-        node: &mut Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_import_layer_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_import_layer_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_import_layer_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_import_layer_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(
-        &mut self,
-        node: &mut Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_important_flag(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_important_flag(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_important_flag(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_important_flag(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(
-        &mut self,
-        node: &mut Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_media_condition_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_media_condition_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_media_condition_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_media_condition_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(
-        &mut self,
-        node: &mut Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_media_query_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_media_query_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_media_query_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_media_query_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(
-        &mut self,
-        node: &mut Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_media_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_media_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_media_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(
-        &mut self,
-        node: &mut Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_namespace(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_namespace(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(
-        &mut self,
-        node: &mut Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_namespace_prefix(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_namespace_prefix(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_namespace_prefix(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_namespace_prefix(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(
-        &mut self,
-        node: &mut Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_nesting_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_nesting_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_nesting_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_nesting_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_number(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_number(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_number(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_number(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_pseudos(
-        &mut self,
-        node: &mut Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_page_selector_pseudos(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_page_selector_pseudos(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_page_selector_pseudos(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_page_selector_pseudos(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(
-        &mut self,
-        node: &mut Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_page_selector_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_page_selector_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_page_selector_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_page_selector_type(visitor, node)
             }
         }
     }
@@ -60637,18 +43183,13 @@ where
     fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_pseudo_class_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_pseudo_class_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_pseudo_class_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_pseudo_class_selector_childrens(visitor, node)
             }
         }
     }
@@ -60657,218 +43198,151 @@ where
     fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_pseudo_element_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_pseudo_element_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_pseudo_element_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_pseudo_element_selector_childrens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(
-        &mut self,
-        node: &mut Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_simple_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_simple_block(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_simple_block(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_simple_block(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(
-        &mut self,
-        node: &mut Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_type_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_type_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_type_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_type_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(
-        &mut self,
-        node: &mut Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_url_modifiers(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_url_modifiers(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_url_modifiers(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_url_modifiers(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(
-        &mut self,
-        node: &mut Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_url_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_url_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_url_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_url_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_page_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_page_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_list(
-        &mut self,
-        node: &mut PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(
-        &mut self,
-        node: &mut PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_pseudo(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_pseudo(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_pseudo(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_pseudo(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(
-        &mut self,
-        node: &mut Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_pseudos(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_pseudos(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_pseudos(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_pseudos(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(
-        &mut self,
-        node: &mut PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_page_selector_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_page_selector_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_page_selectors(
-        &mut self,
-        node: &mut Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_page_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_page_selectors(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_page_selectors(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_page_selectors(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
+    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_percentage(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_percentage(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(
-        &mut self,
-        node: &mut PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_class_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_pseudo_class_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_class_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_pseudo_class_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(
-        &mut self,
-        node: &mut PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_class_selector_children(visitor, node, __ast_path)
+                VisitMut::visit_mut_pseudo_class_selector_children(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_class_selector_children(visitor, node, __ast_path)
+                VisitMut::visit_mut_pseudo_class_selector_children(visitor, node)
             }
         }
     }
@@ -60877,34 +43351,25 @@ where
     fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_class_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_pseudo_class_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_class_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_pseudo_class_selector_childrens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(
-        &mut self,
-        node: &mut PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_element_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_pseudo_element_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_element_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_pseudo_element_selector(visitor, node)
             }
         }
     }
@@ -60913,18 +43378,13 @@ where
     fn visit_mut_pseudo_element_selector_children(
         &mut self,
         node: &mut PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_element_selector_children(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_pseudo_element_selector_children(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_element_selector_children(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_pseudo_element_selector_children(visitor, node)
             }
         }
     }
@@ -60933,892 +43393,623 @@ where
     fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_element_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_pseudo_element_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pseudo_element_selector_childrens(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_pseudo_element_selector_childrens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_qualified_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_qualified_rule(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_qualified_rule(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_qualified_rule(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_qualified_rule_prelude(
-        &mut self,
-        node: &mut QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_qualified_rule_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_qualified_rule_prelude(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_qualified_rule_prelude(visitor, node, __ast_path)
+                VisitMut::visit_mut_qualified_rule_prelude(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(
-        &mut self,
-        node: &mut QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_query_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_query_in_parens(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_query_in_parens(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_query_in_parens(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ratio(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ratio(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ratio(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ratio(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector(
-        &mut self,
-        node: &mut RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_relative_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_relative_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_relative_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_relative_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(
-        &mut self,
-        node: &mut RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_relative_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_relative_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_relative_selector_list(visitor, node, __ast_path)
+                VisitMut::visit_mut_relative_selector_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(
-        &mut self,
-        node: &mut Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_relative_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_relative_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_relative_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_relative_selectors(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
+    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_resolution(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_resolution(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_resolution(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_resolution(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
+    fn visit_mut_rule(&mut self, node: &mut Rule) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_rule(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_rule(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_rule(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_rules(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_rules(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_rules(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_rules(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_scope_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_scope_range(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_scope_range(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_scope_range(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_selector_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_selector_list(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_selector_list(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(
-        &mut self,
-        node: &mut SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_sequence_of_custom_idents(visitor, node, __ast_path)
+                VisitMut::visit_mut_sequence_of_custom_idents(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_sequence_of_custom_idents(visitor, node, __ast_path)
+                VisitMut::visit_mut_sequence_of_custom_idents(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_simple_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_simple_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_simple_block(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_simple_block(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_size_feature(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_size_feature(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(
-        &mut self,
-        node: &mut SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_boolean(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_boolean(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_boolean(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_boolean(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(
-        &mut self,
-        node: &mut SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(
-        &mut self,
-        node: &mut SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_plain(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_plain(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_plain(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_plain(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(
-        &mut self,
-        node: &mut SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_range(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_range(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_range(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_range(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(
-        &mut self,
-        node: &mut SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_range_comparison(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_range_comparison(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_range_comparison(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_range_comparison(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(
-        &mut self,
-        node: &mut SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_range_interval(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_range_interval(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_range_interval(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_range_interval(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(
-        &mut self,
-        node: &mut SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_size_feature_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_size_feature_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_span(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_span(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+    fn visit_mut_str(&mut self, node: &mut Str) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_str(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_str(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_style_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_style_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_style_block(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_style_block(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_stylesheet(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_stylesheet(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_stylesheet(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_stylesheet(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(
-        &mut self,
-        node: &mut SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_subclass_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_subclass_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_subclass_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_subclass_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(
-        &mut self,
-        node: &mut Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_subclass_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_subclass_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_subclass_selectors(visitor, node, __ast_path)
+                VisitMut::visit_mut_subclass_selectors(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_and(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_and(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_supports_and(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition(
-        &mut self,
-        node: &mut SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_condition(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_condition(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_condition(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_condition(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(
-        &mut self,
-        node: &mut SupportsConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_condition_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_condition_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_condition_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_condition_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(
-        &mut self,
-        node: &mut Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_condition_types(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_condition_types(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_condition_types(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_condition_types(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_feature(
-        &mut self,
-        node: &mut SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_feature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_feature(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_feature(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_feature(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(
-        &mut self,
-        node: &mut SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_in_parens(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_in_parens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_in_parens(visitor, node, __ast_path)
+                VisitMut::visit_mut_supports_in_parens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_not(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_not(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_supports_not(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_supports_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_supports_or(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_supports_or(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_supports_or(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(
-        &mut self,
-        node: &mut TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_tag_name_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_tag_name_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_tag_name_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_tag_name_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
+    fn visit_mut_time(&mut self, node: &mut Time) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_time(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_time(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_time(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_time(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_time_percentage(
-        &mut self,
-        node: &mut TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_time_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_time_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_time_percentage(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_time_percentage(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
+    fn visit_mut_token(&mut self, node: &mut Token) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_token(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_token(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_token(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_token(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_token_and_span(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_token_and_span(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_token_and_span(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_token_and_span(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_type_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_type_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_type_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_type_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_unicode_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_unicode_range(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_unicode_range(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_unicode_range(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_universal_selector(
-        &mut self,
-        node: &mut UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_universal_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_universal_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_universal_selector(visitor, node, __ast_path)
+                VisitMut::visit_mut_universal_selector(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(
-        &mut self,
-        node: &mut UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_unknown_dimension(visitor, node, __ast_path)
+                VisitMut::visit_mut_unknown_dimension(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_unknown_dimension(visitor, node, __ast_path)
+                VisitMut::visit_mut_unknown_dimension(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url(&mut self, node: &mut Url) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_url(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_url(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_url_key_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_url_key_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_key_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_key_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_url_modifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_url_modifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_modifier(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_modifier(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(
-        &mut self,
-        node: &mut Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_url_modifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_url_modifiers(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_modifiers(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_modifiers(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_url_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_url_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_url_value_raw(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_url_value_raw(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_url_value_raw(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_url_value_raw(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_wq_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_wq_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_wq_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_wq_name(visitor, node),
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitMutAstPath for ::swc_visit::Optional<V>
+impl<V> VisitMut for ::swc_visit::Optional<V>
 where
-    V: VisitMutAstPath,
+    V: VisitMut,
 {
     #[inline]
-    fn visit_mut_absolute_color_base(
-        &mut self,
-        node: &mut AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_absolute_color_base(&mut self, node: &mut AbsoluteColorBase) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_absolute_color_base(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_absolute_color_base(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_alpha_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_alpha_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_an_plus_b(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_an_plus_b(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_an_plus_b_notation(
-        &mut self,
-        node: &mut AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_an_plus_b_notation(&mut self, node: &mut AnPlusBNotation) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_an_plus_b_notation(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
+    fn visit_mut_angle(&mut self, node: &mut Angle) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_angle(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_angle(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_angle_percentage(
-        &mut self,
-        node: &mut AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_angle_percentage(&mut self, node: &mut AnglePercentage) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_angle_percentage(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_angle_percentage(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_any_namespace(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_any_namespace(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_at_rule(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_at_rule(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_at_rule_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_at_rule_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_at_rule_prelude(
-        &mut self,
-        node: &mut AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_at_rule_prelude(&mut self, node: &mut AtRulePrelude) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_at_rule_prelude(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_at_rule_prelude(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_atom(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_atom(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector(
-        &mut self,
-        node: &mut AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector(&mut self, node: &mut AttributeSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_attribute_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_attribute_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_matcher(
-        &mut self,
-        node: &mut AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector_matcher(&mut self, node: &mut AttributeSelectorMatcher) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_attribute_selector_matcher(&mut self.visitor, node)
         } else {
         }
     }
@@ -61827,646 +44018,409 @@ where
     fn visit_mut_attribute_selector_matcher_value(
         &mut self,
         node: &mut AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_attribute_selector_matcher_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_modifier(
-        &mut self,
-        node: &mut AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector_modifier(&mut self, node: &mut AttributeSelectorModifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_attribute_selector_modifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_attribute_selector_value(
-        &mut self,
-        node: &mut AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_attribute_selector_value(&mut self, node: &mut AttributeSelectorValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_attribute_selector_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_attribute_selector_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_bin_op(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_bin_op(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_operator(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_calc_operator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_operator_type(
-        &mut self,
-        node: &mut CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_operator_type(&mut self, node: &mut CalcOperatorType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_operator_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_calc_operator_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_product(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_calc_product(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operator(
-        &mut self,
-        node: &mut CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_product_or_operator(&mut self, node: &mut CalcProductOrOperator) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_calc_product_or_operator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_product_or_operators(
-        &mut self,
-        node: &mut Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_product_or_operators(&mut self, node: &mut Vec<CalcProductOrOperator>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_calc_product_or_operators(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_sum(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_calc_sum(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_calc_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operator(
-        &mut self,
-        node: &mut CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_value_or_operator(&mut self, node: &mut CalcValueOrOperator) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_calc_value_or_operator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_calc_value_or_operators(
-        &mut self,
-        node: &mut Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_calc_value_or_operators(&mut self, node: &mut Vec<CalcValueOrOperator>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_calc_value_or_operators(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_cmyk_component(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_cmyk_component(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
+    fn visit_mut_color(&mut self, node: &mut Color) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_color(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_color(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_color_profile_name(
-        &mut self,
-        node: &mut ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_color_profile_name(&mut self, node: &mut ColorProfileName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_color_profile_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_color_profile_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_combinator(&mut self, node: &mut Combinator) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_combinator(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_combinator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_combinator_value(
-        &mut self,
-        node: &mut CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_combinator_value(&mut self, node: &mut CombinatorValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_combinator_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_combinator_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector(
-        &mut self,
-        node: &mut ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selector(&mut self, node: &mut ComplexSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_complex_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_complex_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_children(
-        &mut self,
-        node: &mut ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selector_children(&mut self, node: &mut ComplexSelectorChildren) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_complex_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_complex_selector_children(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selector_childrens(
-        &mut self,
-        node: &mut Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selector_childrens(&mut self, node: &mut Vec<ComplexSelectorChildren>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_complex_selector_childrens(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_complex_selectors(
-        &mut self,
-        node: &mut Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_complex_selectors(&mut self, node: &mut Vec<ComplexSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_complex_selectors(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_complex_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_component_value(
-        &mut self,
-        node: &mut ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_component_value(&mut self, node: &mut ComponentValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_component_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_component_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_component_values(
-        &mut self,
-        node: &mut Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_component_values(&mut self, node: &mut Vec<ComponentValue>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_component_values(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_component_values(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector(
-        &mut self,
-        node: &mut CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_compound_selector(&mut self, node: &mut CompoundSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_compound_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_compound_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selector_list(
-        &mut self,
-        node: &mut CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_compound_selector_list(&mut self, node: &mut CompoundSelectorList) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_compound_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_compound_selector_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_compound_selectors(
-        &mut self,
-        node: &mut Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_compound_selectors(&mut self, node: &mut Vec<CompoundSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_compound_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_compound_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_condition(
-        &mut self,
-        node: &mut ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_condition(&mut self, node: &mut ContainerCondition) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_condition(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_container_condition(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_container_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query(
-        &mut self,
-        node: &mut ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query(&mut self, node: &mut ContainerQuery) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_query(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_container_query(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_and(
-        &mut self,
-        node: &mut ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_and(&mut self, node: &mut ContainerQueryAnd) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_query_and(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_container_query_and(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_not(
-        &mut self,
-        node: &mut ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_not(&mut self, node: &mut ContainerQueryNot) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_query_not(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_container_query_not(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_or(
-        &mut self,
-        node: &mut ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_or(&mut self, node: &mut ContainerQueryOr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_query_or(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_container_query_or(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_type(
-        &mut self,
-        node: &mut ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_type(&mut self, node: &mut ContainerQueryType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_query_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_container_query_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_container_query_types(
-        &mut self,
-        node: &mut Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_container_query_types(&mut self, node: &mut Vec<ContainerQueryType>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_container_query_types(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_container_query_types(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_highlight_name(
-        &mut self,
-        node: &mut CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_highlight_name(&mut self, node: &mut CustomHighlightName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_custom_highlight_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_custom_highlight_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_custom_ident(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_custom_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_idents(
-        &mut self,
-        node: &mut Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_idents(&mut self, node: &mut Vec<CustomIdent>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_custom_idents(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_custom_idents(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query(
-        &mut self,
-        node: &mut CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_media_query(&mut self, node: &mut CustomMediaQuery) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_custom_media_query(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_custom_media_query(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_media_query_media_type(
-        &mut self,
-        node: &mut CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_media_query_media_type(&mut self, node: &mut CustomMediaQueryMediaType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_custom_media_query_media_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_custom_property_name(
-        &mut self,
-        node: &mut CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_custom_property_name(&mut self, node: &mut CustomPropertyName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_custom_property_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_custom_property_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_dashed_ident(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_dashed_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
+    fn visit_mut_declaration(&mut self, node: &mut Declaration) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_declaration(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_declaration(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_name(
-        &mut self,
-        node: &mut DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_declaration_name(&mut self, node: &mut DeclarationName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_declaration_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_declaration_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_declaration_or_at_rule(
-        &mut self,
-        node: &mut DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_declaration_or_at_rule(&mut self, node: &mut DeclarationOrAtRule) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_declaration_or_at_rule(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_delimiter(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_delimiter(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_delimiter_value(
-        &mut self,
-        node: &mut DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_delimiter_value(&mut self, node: &mut DelimiterValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_delimiter_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_delimiter_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
+    fn visit_mut_dimension(&mut self, node: &mut Dimension) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_dimension(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_dimension(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_dimension_token(
-        &mut self,
-        node: &mut DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_dimension_token(&mut self, node: &mut DimensionToken) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_dimension_token(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_dimension_token(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_document_prelude(
-        &mut self,
-        node: &mut DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_document_prelude(&mut self, node: &mut DocumentPrelude) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_document_prelude(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_document_prelude(&mut self.visitor, node)
         } else {
         }
     }
@@ -62475,14 +44429,9 @@ where
     fn visit_mut_document_prelude_matching_function(
         &mut self,
         node: &mut DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_document_prelude_matching_function(&mut self.visitor, node)
         } else {
         }
     }
@@ -62491,110 +44440,73 @@ where
     fn visit_mut_document_prelude_matching_functions(
         &mut self,
         node: &mut Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_document_prelude_matching_functions(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_extension_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_extension_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_family_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_family_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_family_names(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_family_names(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
+    fn visit_mut_flex(&mut self, node: &mut Flex) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_flex(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_flex(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_font_feature_values_prelude(
-        &mut self,
-        node: &mut FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_font_feature_values_prelude(&mut self, node: &mut FontFeatureValuesPrelude) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_font_feature_values_prelude(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selector(
-        &mut self,
-        node: &mut ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_complex_selector(&mut self, node: &mut ForgivingComplexSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_forgiving_complex_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_complex_selectors(
-        &mut self,
-        node: &mut Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_complex_selectors(&mut self, node: &mut Vec<ForgivingComplexSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_forgiving_complex_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_relative_selector(
-        &mut self,
-        node: &mut ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_relative_selector(&mut self, node: &mut ForgivingRelativeSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_forgiving_relative_selector(&mut self.visitor, node)
         } else {
         }
     }
@@ -62603,14 +44515,9 @@ where
     fn visit_mut_forgiving_relative_selector_list(
         &mut self,
         node: &mut ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_forgiving_relative_selector_list(&mut self.visitor, node)
         } else {
         }
     }
@@ -62619,410 +44526,297 @@ where
     fn visit_mut_forgiving_relative_selectors(
         &mut self,
         node: &mut Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_forgiving_relative_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_forgiving_selector_list(
-        &mut self,
-        node: &mut ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_forgiving_selector_list(&mut self, node: &mut ForgivingSelectorList) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_forgiving_selector_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
+    fn visit_mut_frequency(&mut self, node: &mut Frequency) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_frequency(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_frequency(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_frequency_percentage(
-        &mut self,
-        node: &mut FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_frequency_percentage(&mut self, node: &mut FrequencyPercentage) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_frequency_percentage(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_frequency_percentage(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+    fn visit_mut_function(&mut self, node: &mut Function) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_function(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_function(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_function_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_function_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_general_enclosed(
-        &mut self,
-        node: &mut GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_general_enclosed(&mut self, node: &mut GeneralEnclosed) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_general_enclosed(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_general_enclosed(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_hex_color(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_hex_color(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_hue(&mut self, node: &mut Hue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_hue(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_hue(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_id_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_id_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ident(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_idents(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_idents(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_conditions(
-        &mut self,
-        node: &mut ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_conditions(&mut self, node: &mut ImportConditions) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_conditions(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_conditions(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_href(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_href(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_layer_name(
-        &mut self,
-        node: &mut ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_layer_name(&mut self, node: &mut ImportLayerName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_layer_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_layer_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_prelude(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_prelude(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_important_flag(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_important_flag(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
+    fn visit_mut_integer(&mut self, node: &mut Integer) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_integer(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_integer(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_keyframe_block(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_keyframe_block(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selector(
-        &mut self,
-        node: &mut KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframe_selector(&mut self, node: &mut KeyframeSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_keyframe_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_keyframe_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframe_selectors(
-        &mut self,
-        node: &mut Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframe_selectors(&mut self, node: &mut Vec<KeyframeSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_keyframe_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_keyframe_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_keyframes_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_keyframes_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_function(
-        &mut self,
-        node: &mut KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframes_pseudo_function(&mut self, node: &mut KeyframesPseudoFunction) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_keyframes_pseudo_function(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_keyframes_pseudo_prefix(
-        &mut self,
-        node: &mut KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_keyframes_pseudo_prefix(&mut self, node: &mut KeyframesPseudoPrefix) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_layer_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_layer_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_name_list(
-        &mut self,
-        node: &mut LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_layer_name_list(&mut self, node: &mut LayerNameList) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_layer_name_list(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_layer_name_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_layer_names(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_layer_names(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_layer_prelude(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_layer_prelude(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
+    fn visit_mut_length(&mut self, node: &mut Length) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_length(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_length(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_length_percentage(
-        &mut self,
-        node: &mut LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_length_percentage(&mut self, node: &mut LengthPercentage) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_length_percentage(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_length_percentage(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_list_of_component_values(
-        &mut self,
-        node: &mut ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_list_of_component_values(&mut self, node: &mut ListOfComponentValues) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_list_of_component_values(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_list_of_component_values(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_and(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_and(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition(
-        &mut self,
-        node: &mut MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition(&mut self, node: &mut MediaCondition) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_condition(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_condition(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_type(
-        &mut self,
-        node: &mut MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_all_type(&mut self, node: &mut MediaConditionAllType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_condition_all_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_condition_all_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_all_types(
-        &mut self,
-        node: &mut Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_all_types(&mut self, node: &mut Vec<MediaConditionAllType>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_condition_all_types(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_condition_all_types(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_type(
-        &mut self,
-        node: &mut MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_type(&mut self, node: &mut MediaConditionType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_condition_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_condition_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_condition_without_or(
-        &mut self,
-        node: &mut MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_condition_without_or(&mut self, node: &mut MediaConditionWithoutOr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_condition_without_or(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_condition_without_or(&mut self.visitor, node)
         } else {
         }
     }
@@ -63031,14 +44825,9 @@ where
     fn visit_mut_media_condition_without_or_type(
         &mut self,
         node: &mut MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_condition_without_or_type(&mut self.visitor, node)
         } else {
         }
     }
@@ -63047,314 +44836,209 @@ where
     fn visit_mut_media_condition_without_or_types(
         &mut self,
         node: &mut Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_condition_without_or_types(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_feature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_boolean(
-        &mut self,
-        node: &mut MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_boolean(&mut self, node: &mut MediaFeatureBoolean) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature_boolean(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_feature_boolean(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_name(
-        &mut self,
-        node: &mut MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_name(&mut self, node: &mut MediaFeatureName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_feature_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_plain(
-        &mut self,
-        node: &mut MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_plain(&mut self, node: &mut MediaFeaturePlain) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature_plain(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_feature_plain(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range(
-        &mut self,
-        node: &mut MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_range(&mut self, node: &mut MediaFeatureRange) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature_range(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_feature_range(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_comparison(
-        &mut self,
-        node: &mut MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_range_comparison(&mut self, node: &mut MediaFeatureRangeComparison) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_feature_range_comparison(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_range_interval(
-        &mut self,
-        node: &mut MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_range_interval(&mut self, node: &mut MediaFeatureRangeInterval) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_feature_range_interval(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_feature_value(
-        &mut self,
-        node: &mut MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_feature_value(&mut self, node: &mut MediaFeatureValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_feature_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_media_feature_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_in_parens(
-        &mut self,
-        node: &mut MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_in_parens(&mut self, node: &mut MediaInParens) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_in_parens(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_in_parens(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_not(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_not(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_or(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_or(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_query(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_query(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_query_list(
-        &mut self,
-        node: &mut MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_media_query_list(&mut self, node: &mut MediaQueryList) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_query_list(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_query_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_querys(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_querys(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_media_type(&mut self, node: &mut MediaType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_media_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_media_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_named_namespace(
-        &mut self,
-        node: &mut NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_named_namespace(&mut self, node: &mut NamedNamespace) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_named_namespace(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_named_namespace(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
+    fn visit_mut_namespace(&mut self, node: &mut Namespace) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_namespace(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_namespace(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prefix(
-        &mut self,
-        node: &mut NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_namespace_prefix(&mut self, node: &mut NamespacePrefix) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_namespace_prefix(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_namespace_prefix(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude(
-        &mut self,
-        node: &mut NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_namespace_prelude(&mut self, node: &mut NamespacePrelude) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_namespace_prelude(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_namespace_prelude(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_namespace_prelude_uri(
-        &mut self,
-        node: &mut NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_namespace_prelude_uri(&mut self, node: &mut NamespacePreludeUri) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_namespace_prelude_uri(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_nesting_selector(
-        &mut self,
-        node: &mut NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_nesting_selector(&mut self, node: &mut NestingSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_nesting_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_nesting_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+    fn visit_mut_number(&mut self, node: &mut Number) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_number(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_number(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_number_type(&mut self, node: &mut NumberType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_number_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_number_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_at_rule_prelude(
-        &mut self,
-        node: &mut Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_at_rule_prelude(&mut self, node: &mut Option<Box<AtRulePrelude>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_at_rule_prelude(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_atom(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_atom(&mut self.visitor, node)
         } else {
         }
     }
@@ -63363,14 +45047,9 @@ where
     fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
         node: &mut Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(&mut self.visitor, node)
         } else {
         }
     }
@@ -63379,14 +45058,9 @@ where
     fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
         node: &mut Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(&mut self.visitor, node)
         } else {
         }
     }
@@ -63395,254 +45069,145 @@ where
     fn visit_mut_opt_attribute_selector_value(
         &mut self,
         node: &mut Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_attribute_selector_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_combinator(
-        &mut self,
-        node: &mut Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_combinator(&mut self, node: &mut Option<Combinator>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_combinator(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_combinator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_container_name(
-        &mut self,
-        node: &mut Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_container_name(&mut self, node: &mut Option<ContainerName>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_container_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_container_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_forgiving_selector_list(
-        &mut self,
-        node: &mut Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_forgiving_selector_list(&mut self, node: &mut Option<ForgivingSelectorList>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_forgiving_selector_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_function(
-        &mut self,
-        node: &mut Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_function(&mut self, node: &mut Option<Box<Function>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_function(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_function(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ident(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_conditions(
-        &mut self,
-        node: &mut Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_import_conditions(&mut self, node: &mut Option<Box<ImportConditions>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_import_conditions(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_import_conditions(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_import_layer_name(
-        &mut self,
-        node: &mut Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_import_layer_name(&mut self, node: &mut Option<Box<ImportLayerName>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_import_layer_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_important_flag(
-        &mut self,
-        node: &mut Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_important_flag(&mut self, node: &mut Option<ImportantFlag>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_important_flag(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_important_flag(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_condition_type(
-        &mut self,
-        node: &mut Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_media_condition_type(&mut self, node: &mut Option<Box<MediaConditionType>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_media_condition_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_query_list(
-        &mut self,
-        node: &mut Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_media_query_list(&mut self, node: &mut Option<Box<MediaQueryList>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_media_query_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_media_query_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_media_type(
-        &mut self,
-        node: &mut Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_media_type(&mut self, node: &mut Option<MediaType>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_media_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_media_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace(
-        &mut self,
-        node: &mut Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_namespace(&mut self, node: &mut Option<Namespace>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_namespace(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_namespace(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_namespace_prefix(
-        &mut self,
-        node: &mut Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_namespace_prefix(&mut self, node: &mut Option<NamespacePrefix>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_namespace_prefix(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_nesting_selector(
-        &mut self,
-        node: &mut Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_nesting_selector(&mut self, node: &mut Option<NestingSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_nesting_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_number(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_number(&mut self.visitor, node)
         } else {
         }
     }
 
-    #[inline]
-    fn visit_mut_opt_page_selector_pseudos(
-        &mut self,
-        node: &mut Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+    #[inline]
+    fn visit_mut_opt_page_selector_pseudos(&mut self, node: &mut Option<Vec<PageSelectorPseudo>>) {
+        if self.enabled {
+            <V as VisitMut>::visit_mut_opt_page_selector_pseudos(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_page_selector_type(
-        &mut self,
-        node: &mut Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_page_selector_type(&mut self, node: &mut Option<PageSelectorType>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_page_selector_type(&mut self.visitor, node)
         } else {
         }
     }
@@ -63651,14 +45216,9 @@ where
     fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(&mut self.visitor, node)
         } else {
         }
     }
@@ -63667,186 +45227,116 @@ where
     fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
+            <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(
                 &mut self.visitor,
                 node,
-                __ast_path,
             )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_simple_block(
-        &mut self,
-        node: &mut Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_simple_block(&mut self, node: &mut Option<SimpleBlock>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_simple_block(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_simple_block(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_type_selector(
-        &mut self,
-        node: &mut Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_type_selector(&mut self, node: &mut Option<Box<TypeSelector>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_type_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_type_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_modifiers(
-        &mut self,
-        node: &mut Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_url_modifiers(&mut self, node: &mut Option<Vec<UrlModifier>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_url_modifiers(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_url_value(
-        &mut self,
-        node: &mut Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_url_value(&mut self, node: &mut Option<Box<UrlValue>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_url_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_url_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_page_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_page_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_list(
-        &mut self,
-        node: &mut PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_list(&mut self, node: &mut PageSelectorList) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_page_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_page_selector_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudo(
-        &mut self,
-        node: &mut PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_pseudo(&mut self, node: &mut PageSelectorPseudo) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_page_selector_pseudo(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_pseudos(
-        &mut self,
-        node: &mut Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_pseudos(&mut self, node: &mut Vec<PageSelectorPseudo>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_page_selector_pseudos(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selector_type(
-        &mut self,
-        node: &mut PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selector_type(&mut self, node: &mut PageSelectorType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_page_selector_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_page_selector_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_page_selectors(
-        &mut self,
-        node: &mut Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_page_selectors(&mut self, node: &mut Vec<PageSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_page_selectors(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_page_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
+    fn visit_mut_percentage(&mut self, node: &mut Percentage) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_percentage(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_percentage(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector(
-        &mut self,
-        node: &mut PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_pseudo_class_selector(&mut self, node: &mut PseudoClassSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_pseudo_class_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_class_selector_children(
-        &mut self,
-        node: &mut PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_pseudo_class_selector_children(&mut self, node: &mut PseudoClassSelectorChildren) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_pseudo_class_selector_children(&mut self.visitor, node)
         } else {
         }
     }
@@ -63855,30 +45345,17 @@ where
     fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pseudo_element_selector(
-        &mut self,
-        node: &mut PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_pseudo_element_selector(&mut self, node: &mut PseudoElementSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_pseudo_element_selector(&mut self.visitor, node)
         } else {
         }
     }
@@ -63887,14 +45364,9 @@ where
     fn visit_mut_pseudo_element_selector_children(
         &mut self,
         node: &mut PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_pseudo_element_selector_children(&mut self.visitor, node)
         } else {
         }
     }
@@ -63903,724 +45375,497 @@ where
     fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_qualified_rule(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_qualified_rule(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_qualified_rule_prelude(
-        &mut self,
-        node: &mut QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_qualified_rule_prelude(&mut self, node: &mut QualifiedRulePrelude) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_qualified_rule_prelude(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_query_in_parens(
-        &mut self,
-        node: &mut QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_query_in_parens(&mut self, node: &mut QueryInParens) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_query_in_parens(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_query_in_parens(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ratio(&mut self, node: &mut Ratio) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ratio(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ratio(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector(
-        &mut self,
-        node: &mut RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_relative_selector(&mut self, node: &mut RelativeSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_relative_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_relative_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selector_list(
-        &mut self,
-        node: &mut RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_relative_selector_list(&mut self, node: &mut RelativeSelectorList) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_relative_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_relative_selector_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_relative_selectors(
-        &mut self,
-        node: &mut Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_relative_selectors(&mut self, node: &mut Vec<RelativeSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_relative_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_relative_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
+    fn visit_mut_resolution(&mut self, node: &mut Resolution) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_resolution(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_resolution(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
+    fn visit_mut_rule(&mut self, node: &mut Rule) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_rule(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_rule(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_rules(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_rules(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_scope_range(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_scope_range(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_selector_list(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_selector_list(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_sequence_of_custom_idents(
-        &mut self,
-        node: &mut SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_sequence_of_custom_idents(&mut self, node: &mut SequenceOfCustomIdents) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_sequence_of_custom_idents(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_simple_block(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_simple_block(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_size_feature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_boolean(
-        &mut self,
-        node: &mut SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_boolean(&mut self, node: &mut SizeFeatureBoolean) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature_boolean(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_size_feature_boolean(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_name(
-        &mut self,
-        node: &mut SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_name(&mut self, node: &mut SizeFeatureName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_size_feature_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_plain(
-        &mut self,
-        node: &mut SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_plain(&mut self, node: &mut SizeFeaturePlain) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature_plain(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_size_feature_plain(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range(
-        &mut self,
-        node: &mut SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_range(&mut self, node: &mut SizeFeatureRange) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature_range(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_size_feature_range(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_comparison(
-        &mut self,
-        node: &mut SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_range_comparison(&mut self, node: &mut SizeFeatureRangeComparison) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_size_feature_range_comparison(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_range_interval(
-        &mut self,
-        node: &mut SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_range_interval(&mut self, node: &mut SizeFeatureRangeInterval) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_size_feature_range_interval(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_size_feature_value(
-        &mut self,
-        node: &mut SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_size_feature_value(&mut self, node: &mut SizeFeatureValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_size_feature_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_size_feature_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_span(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_span(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+    fn visit_mut_str(&mut self, node: &mut Str) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_str(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_str(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_style_block(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_style_block(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_stylesheet(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_stylesheet(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selector(
-        &mut self,
-        node: &mut SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_subclass_selector(&mut self, node: &mut SubclassSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_subclass_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_subclass_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_subclass_selectors(
-        &mut self,
-        node: &mut Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_subclass_selectors(&mut self, node: &mut Vec<SubclassSelector>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_subclass_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_subclass_selectors(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_and(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_supports_and(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition(
-        &mut self,
-        node: &mut SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_condition(&mut self, node: &mut SupportsCondition) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_condition(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_supports_condition(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_type(
-        &mut self,
-        node: &mut SupportsConditionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_condition_type(&mut self, node: &mut SupportsConditionType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_condition_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_supports_condition_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_condition_types(
-        &mut self,
-        node: &mut Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_condition_types(&mut self, node: &mut Vec<SupportsConditionType>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_condition_types(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_supports_condition_types(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_feature(
-        &mut self,
-        node: &mut SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_feature(&mut self, node: &mut SupportsFeature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_feature(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_supports_feature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_in_parens(
-        &mut self,
-        node: &mut SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_supports_in_parens(&mut self, node: &mut SupportsInParens) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_in_parens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_supports_in_parens(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_not(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_supports_not(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_supports_or(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_supports_or(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tag_name_selector(
-        &mut self,
-        node: &mut TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_tag_name_selector(&mut self, node: &mut TagNameSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_tag_name_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_tag_name_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
+    fn visit_mut_time(&mut self, node: &mut Time) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_time(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_time(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_time_percentage(
-        &mut self,
-        node: &mut TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_time_percentage(&mut self, node: &mut TimePercentage) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_time_percentage(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_time_percentage(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
+    fn visit_mut_token(&mut self, node: &mut Token) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_token(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_token(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_token_and_span(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_token_and_span(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_type_selector(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_type_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_unicode_range(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_unicode_range(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_universal_selector(
-        &mut self,
-        node: &mut UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_universal_selector(&mut self, node: &mut UniversalSelector) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_universal_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_universal_selector(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unknown_dimension(
-        &mut self,
-        node: &mut UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_unknown_dimension(&mut self, node: &mut UnknownDimension) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_unknown_dimension(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_unknown_dimension(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url(&mut self, node: &mut Url) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_url(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_url(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_url_key_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_url_key_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_url_modifier(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_url_modifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_modifiers(
-        &mut self,
-        node: &mut Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_url_modifiers(&mut self, node: &mut Vec<UrlModifier>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_url_modifiers(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_url_modifiers(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_url_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_url_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_url_value_raw(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_url_value_raw(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_wq_name(&mut self, node: &mut WqName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_wq_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_wq_name(&mut self.visitor, node)
         } else {
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitMutWithAstPath<V: ?Sized + VisitMutAstPath> {
+pub trait VisitMutWith<V: ?Sized + VisitMut> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
+    fn visit_mut_with(&mut self, visitor: &mut V);
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
+    fn visit_mut_children_with(&mut self, visitor: &mut V);
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AbsoluteColorBase {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_absolute_color_base`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_absolute_color_base(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AbsoluteColorBase {
+    #[doc = "Calls [VisitMut`::visit_mut_absolute_color_base`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_absolute_color_base(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AbsoluteColorBase::HexColor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
-                    self::fields::AbsoluteColorBaseField::HexColor,
-                ));
-                <HexColor as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <HexColor as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
-                    self::fields::AbsoluteColorBaseField::NamedColorOrTransparent,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AbsoluteColorBase::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
-                    self::fields::AbsoluteColorBaseField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AlphaValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_alpha_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_alpha_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AlphaValue {
+    #[doc = "Calls [VisitMut`::visit_mut_alpha_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_alpha_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AlphaValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
-                    self::fields::AlphaValueField::Number,
-                ));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AlphaValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
-                    self::fields::AlphaValueField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnPlusB {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_an_plus_b`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_an_plus_b(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnPlusB {
+    #[doc = "Calls [VisitMut`::visit_mut_an_plus_b`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_an_plus_b(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AnPlusB::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::AnPlusB(self::fields::AnPlusBField::Ident));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AnPlusB::AnPlusBNotation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusB(
-                    self::fields::AnPlusBField::AnPlusBNotation,
-                ));
-                <AnPlusBNotation as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AnPlusBNotation as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnPlusBNotation {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_an_plus_b_notation`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnPlusBNotation {
+    #[doc = "Calls [VisitMut`::visit_mut_an_plus_b_notation`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_an_plus_b_notation(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AnPlusBNotation {
                 span,
@@ -64630,148 +45875,80 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnPlusBNotation {
                 b_raw,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
-                        self::fields::AnPlusBNotationField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
-                        self::fields::AnPlusBNotationField::ARaw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        a_raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(a_raw, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
-                        self::fields::AnPlusBNotationField::BRaw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        b_raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(b_raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Angle {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_angle`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_angle(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Angle {
+    #[doc = "Calls [VisitMut`::visit_mut_angle`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_angle(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Angle { span, value, unit } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Angle(self::fields::AngleField::Value));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Unit));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnglePercentage {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_angle_percentage`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_angle_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnglePercentage {
+    #[doc = "Calls [VisitMut`::visit_mut_angle_percentage`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_angle_percentage(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AnglePercentage::Angle { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
-                    self::fields::AnglePercentageField::Angle,
-                ));
-                <Angle as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Angle as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AnglePercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
-                    self::fields::AnglePercentageField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnyNamespace {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_any_namespace`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_any_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AnyNamespace {
+    #[doc = "Calls [VisitMut`::visit_mut_any_namespace`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_any_namespace(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AnyNamespace { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnyNamespace(
-                        self::fields::AnyNamespaceField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AtRule {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_at_rule`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_at_rule(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AtRule {
+    #[doc = "Calls [VisitMut`::visit_mut_at_rule`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_at_rule(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AtRule {
                 span,
@@ -64780,290 +45957,115 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AtRule {
                 block,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Name));
-                    <AtRuleName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <AtRuleName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Prelude));
-                    <Option<Box<AtRulePrelude>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
+                    <Option<Box<AtRulePrelude>> as VisitMutWith<V>>::visit_mut_with(
+                        prelude, visitor,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Block));
-                    <Option<SimpleBlock> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<SimpleBlock> as VisitMutWith<V>>::visit_mut_with(block, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AtRuleName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_at_rule_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_at_rule_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AtRuleName {
+    #[doc = "Calls [VisitMut`::visit_mut_at_rule_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_at_rule_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AtRuleName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
-                    self::fields::AtRuleNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRuleName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
-                    self::fields::AtRuleNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AtRulePrelude {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_at_rule_prelude`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_at_rule_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AtRulePrelude {
+    #[doc = "Calls [VisitMut`::visit_mut_at_rule_prelude`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_at_rule_prelude(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AtRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ListOfComponentValues,
-                ));
-                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::CharsetPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::CharsetPrelude,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::PropertyPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::PropertyPrelude,
-                ));
-                <CustomPropertyName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomPropertyName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::CounterStylePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::CounterStylePrelude,
-                ));
-                <CustomIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::ColorProfilePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ColorProfilePrelude,
-                ));
-                <ColorProfileName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ColorProfileName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::DocumentPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::DocumentPrelude,
-                ));
-                <DocumentPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DocumentPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::FontPaletteValuesPrelude,
-                ));
-                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::FontFeatureValuesPrelude,
-                ));
-                <FontFeatureValuesPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FontFeatureValuesPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::NestPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::NestPrelude,
-                ));
-                <SelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::KeyframesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::KeyframesPrelude,
-                ));
-                <KeyframesName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <KeyframesName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::ImportPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ImportPrelude,
-                ));
-                <ImportPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::NamespacePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::NamespacePrelude,
-                ));
-                <NamespacePrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NamespacePrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::MediaPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::MediaPrelude,
-                ));
-                <MediaQueryList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaQueryList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::SupportsPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::SupportsPrelude,
-                ));
-                <SupportsCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::PagePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::PagePrelude,
-                ));
-                <PageSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            AtRulePrelude::LayerPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::LayerPrelude,
-                ));
-                <LayerPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PageSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
-            AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ContainerPrelude,
-                ));
-                <ContainerCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+            AtRulePrelude::LayerPrelude { 0: _field_0 } => {
+                <LayerPrelude as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+            }
+            AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
+                <ContainerCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::CustomMediaPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::CustomMediaPrelude,
-                ));
-                <CustomMediaQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomMediaQuery as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AtRulePrelude::ScopePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ScopePrelude,
-                ));
-                <ScopeRange as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ScopeRange as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_attribute_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AttributeSelector {
                 span,
@@ -65073,91 +46075,58 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelector {
                 modifier,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Name,
-                    ));
-                    <WqName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <WqName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Matcher,
-                    ));
-                    < Option < AttributeSelectorMatcher > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (matcher , visitor , & mut * __ast_path)
+                    <Option<AttributeSelectorMatcher> as VisitMutWith<V>>::visit_mut_with(
+                        matcher, visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Value,
-                    ));
-                    < Option < AttributeSelectorValue > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (value , visitor , & mut * __ast_path)
+                    <Option<AttributeSelectorValue> as VisitMutWith<V>>::visit_mut_with(
+                        value, visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Modifier,
-                    ));
-                    < Option < AttributeSelectorModifier > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (modifier , visitor , & mut * __ast_path)
+                    <Option<AttributeSelectorModifier> as VisitMutWith<V>>::visit_mut_with(
+                        modifier, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorMatcher {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_matcher`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorMatcher {
+    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_matcher`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_attribute_selector_matcher(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AttributeSelectorMatcher { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
-                            self::fields::AttributeSelectorMatcherField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
-                            self::fields::AttributeSelectorMatcherField::Value,
-                        ));
-                    < AttributeSelectorMatcherValue as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (value , visitor , & mut * __ast_path)
+                    <AttributeSelectorMatcherValue as VisitMutWith<V>>::visit_mut_with(
+                        value, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorMatcherValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_matcher_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
-            visitor, self, __ast_path,
-        )
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorMatcherValue {
+    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_matcher_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_attribute_selector_matcher_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AttributeSelectorMatcherValue::Equals => {}
             AttributeSelectorMatcherValue::Tilde => {}
@@ -65168,85 +46137,49 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorMa
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorModifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_modifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorModifier {
+    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_modifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_attribute_selector_modifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AttributeSelectorModifier { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
-                            self::fields::AttributeSelectorModifierField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
-                            self::fields::AttributeSelectorModifierField::Value,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_attribute_selector_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AttributeSelectorValue {
+    #[doc = "Calls [VisitMut`::visit_mut_attribute_selector_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_attribute_selector_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AttributeSelectorValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
-                    self::fields::AttributeSelectorValueField::Str,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AttributeSelectorValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
-                    self::fields::AttributeSelectorValueField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinOp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_bin_op`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bin_op(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinOp {
+    #[doc = "Calls [VisitMut`::visit_mut_bin_op`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_bin_op(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BinOp::Add => {}
             BinOp::Sub => {}
@@ -65255,50 +46188,32 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcOperator {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_operator`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_operator(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcOperator {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_operator`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_operator(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CalcOperator { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
-                        self::fields::CalcOperatorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
-                        self::fields::CalcOperatorField::Value,
-                    ));
-                    <CalcOperatorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <CalcOperatorType as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcOperatorType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_operator_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_operator_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcOperatorType {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_operator_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_operator_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CalcOperatorType::Add => {}
             CalcOperatorType::Sub => {}
@@ -65307,410 +46222,215 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcOperatorType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcProduct {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_product`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_product(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcProduct {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_product`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_product(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CalcProduct { span, expressions } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
-                        self::fields::CalcProductField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
-                        self::fields::CalcProductField::Expressions(usize::MAX),
-                    ));
-                    <Vec<CalcValueOrOperator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Vec<CalcValueOrOperator> as VisitMutWith<V>>::visit_mut_with(
                         expressions,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcProductOrOperator {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_product_or_operator`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcProductOrOperator {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_product_or_operator`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_product_or_operator(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CalcProductOrOperator::Product { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
-                    self::fields::CalcProductOrOperatorField::Product,
-                ));
-                <CalcProduct as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcProduct as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CalcProductOrOperator::Operator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
-                    self::fields::CalcProductOrOperatorField::Operator,
-                ));
-                <CalcOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcOperator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcSum {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_sum`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_sum(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcSum {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_sum`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_sum(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CalcSum { span, expressions } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CalcSum(self::fields::CalcSumField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcSum(
-                        self::fields::CalcSumField::Expressions(usize::MAX),
-                    ));
-                    <Vec<CalcProductOrOperator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Vec<CalcProductOrOperator> as VisitMutWith<V>>::visit_mut_with(
                         expressions,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcValue {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CalcValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Number,
-                ));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CalcValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Dimension,
-                ));
-                <Dimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Dimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CalcValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CalcValue::Constant { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Constant,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CalcValue::Sum { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::CalcValue(self::fields::CalcValueField::Sum));
-                <CalcSum as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcSum as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CalcValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcValueOrOperator {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_value_or_operator`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CalcValueOrOperator {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_value_or_operator`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_value_or_operator(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CalcValueOrOperator::Value { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
-                    self::fields::CalcValueOrOperatorField::Value,
-                ));
-                <CalcValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcValue as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CalcValueOrOperator::Operator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
-                    self::fields::CalcValueOrOperatorField::Operator,
-                ));
-                <CalcOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CalcOperator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_class_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ClassSelector { span, text } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
-                        self::fields::ClassSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
-                        self::fields::ClassSelectorField::Text,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        text,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(text, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CmykComponent {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_cmyk_component`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_cmyk_component(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CmykComponent {
+    #[doc = "Calls [VisitMut`::visit_mut_cmyk_component`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_cmyk_component(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CmykComponent::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
-                    self::fields::CmykComponentField::Number,
-                ));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CmykComponent::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
-                    self::fields::CmykComponentField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CmykComponent::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
-                    self::fields::CmykComponentField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Color {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_color`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_color(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Color {
+    #[doc = "Calls [VisitMut`::visit_mut_color`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_color(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Color::AbsoluteColorBase { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
-                    self::fields::ColorField::AbsoluteColorBase,
-                ));
-                <AbsoluteColorBase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            Color::CurrentColorOrSystemColor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
-                    self::fields::ColorField::CurrentColorOrSystemColor,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AbsoluteColorBase as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+            }
+            Color::CurrentColorOrSystemColor { 0: _field_0 } => {
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Color::Function { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Color(self::fields::ColorField::Function));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ColorProfileName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_color_profile_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_color_profile_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ColorProfileName {
+    #[doc = "Calls [VisitMut`::visit_mut_color_profile_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_color_profile_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ColorProfileName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
-                    self::fields::ColorProfileNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ColorProfileName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
-                    self::fields::ColorProfileNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Combinator {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_combinator`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_combinator(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Combinator {
+    #[doc = "Calls [VisitMut`::visit_mut_combinator`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_combinator(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Combinator { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
-                        self::fields::CombinatorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
-                        self::fields::CombinatorField::Value,
-                    ));
-                    <CombinatorValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <CombinatorValue as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CombinatorValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_combinator_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_combinator_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CombinatorValue {
+    #[doc = "Calls [VisitMut`::visit_mut_combinator_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_combinator_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CombinatorValue::Descendant => {}
             CombinatorValue::NextSibling => {}
@@ -65720,412 +46440,158 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CombinatorValue {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComplexSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComplexSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_complex_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_complex_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ComplexSelector { span, children } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
-                        self::fields::ComplexSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
-                        self::fields::ComplexSelectorField::Children(usize::MAX),
-                    ));
-                    < Vec < ComplexSelectorChildren > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Vec<ComplexSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
+                        children, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComplexSelectorChildren {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selector_children`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComplexSelectorChildren {
+    #[doc = "Calls [VisitMut`::visit_mut_complex_selector_children`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_complex_selector_children(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ComplexSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
-                    self::fields::ComplexSelectorChildrenField::CompoundSelector,
-                ));
-                <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComplexSelectorChildren::Combinator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
-                    self::fields::ComplexSelectorChildrenField::Combinator,
-                ));
-                <Combinator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Combinator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComponentValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_component_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_component_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComponentValue {
+    #[doc = "Calls [VisitMut`::visit_mut_component_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_component_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ComponentValue::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::PreservedToken,
-                ));
-                <Box<TokenAndSpan> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TokenAndSpan> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Function,
-                ));
-                <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Function> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::SimpleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::SimpleBlock,
-                ));
-                <Box<SimpleBlock> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<SimpleBlock> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::AtRule,
-                ));
-                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::QualifiedRule,
-                ));
-                <Box<QualifiedRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<QualifiedRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::KeyframeBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::KeyframeBlock,
-                ));
-                <Box<KeyframeBlock> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<KeyframeBlock> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Ident,
-                ));
-                <Box<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Ident> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::DashedIdent,
-                ));
-                <Box<DashedIdent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<DashedIdent> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Str,
-                ));
-                <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Str> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Url,
-                ));
-                <Box<Url> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Url> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Integer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Integer,
-                ));
-                <Box<Integer> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Integer> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Number,
-                ));
-                <Box<Number> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Number> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Percentage,
-                ));
-                <Box<Percentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Percentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Dimension,
-                ));
-                <Box<Dimension> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Dimension> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::LengthPercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::LengthPercentage,
-                ));
-                <Box<LengthPercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<LengthPercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::FrequencyPercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::FrequencyPercentage,
-                ));
-                <Box<FrequencyPercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<FrequencyPercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::AnglePercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::AnglePercentage,
-                ));
-                <Box<AnglePercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AnglePercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::TimePercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::TimePercentage,
-                ));
-                <Box<TimePercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TimePercentage> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Ratio,
-                ));
-                <Box<Ratio> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Ratio> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::UnicodeRange { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::UnicodeRange,
-                ));
-                <Box<UnicodeRange> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<UnicodeRange> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Color { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Color,
-                ));
-                <Box<Color> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Color> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::AlphaValue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::AlphaValue,
-                ));
-                <Box<AlphaValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AlphaValue> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Hue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Hue,
-                ));
-                <Box<Hue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Hue> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::CmykComponent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::CmykComponent,
-                ));
-                <Box<CmykComponent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<CmykComponent> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Delimiter { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Delimiter,
-                ));
-                <Box<Delimiter> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Delimiter> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::CalcSum { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::CalcSum,
-                ));
-                <Box<CalcSum> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<CalcSum> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::ComplexSelector,
-                ));
-                <Box<ComplexSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ComplexSelector> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::LayerName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::LayerName,
-                ));
-                <Box<LayerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<LayerName> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::SupportsCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::SupportsCondition,
-                ));
-                <Box<SupportsCondition> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<SupportsCondition> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Declaration,
-                ));
-                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ComponentValue::IdSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::IdSelector,
-                ));
-                <Box<IdSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<IdSelector> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CompoundSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_compound_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_compound_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CompoundSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_compound_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_compound_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CompoundSelector {
                 span,
@@ -66134,198 +46600,111 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CompoundSelector {
                 subclass_selectors,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::NestingSelector,
-                    ));
-                    <Option<NestingSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<NestingSelector> as VisitMutWith<V>>::visit_mut_with(
                         nesting_selector,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::TypeSelector,
-                    ));
-                    <Option<Box<TypeSelector>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Box<TypeSelector>> as VisitMutWith<V>>::visit_mut_with(
                         type_selector,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::SubclassSelectors(usize::MAX),
-                    ));
-                    <Vec<SubclassSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Vec<SubclassSelector> as VisitMutWith<V>>::visit_mut_with(
                         subclass_selectors,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CompoundSelectorList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_compound_selector_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_compound_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CompoundSelectorList {
+    #[doc = "Calls [VisitMut`::visit_mut_compound_selector_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_compound_selector_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CompoundSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
-                            self::fields::CompoundSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
-                            self::fields::CompoundSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<CompoundSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<CompoundSelector> as VisitMutWith<V>>::visit_mut_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerCondition {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_condition`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_condition(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerCondition {
+    #[doc = "Calls [VisitMut`::visit_mut_container_condition`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_condition(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContainerCondition { span, name, query } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
-                        self::fields::ContainerConditionField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
-                        self::fields::ContainerConditionField::Name,
-                    ));
-                    <Option<ContainerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ContainerName> as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
-                        self::fields::ContainerConditionField::Query,
-                    ));
-                    <ContainerQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ContainerQuery as VisitMutWith<V>>::visit_mut_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerName {
+    #[doc = "Calls [VisitMut`::visit_mut_container_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContainerName::CustomIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerName(
-                    self::fields::ContainerNameField::CustomIdent,
-                ));
-                <CustomIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQuery {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_query(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQuery {
+    #[doc = "Calls [VisitMut`::visit_mut_container_query`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_query(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContainerQuery { span, queries } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
-                        self::fields::ContainerQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
-                        self::fields::ContainerQueryField::Queries(usize::MAX),
-                    ));
-                    <Vec<ContainerQueryType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        queries,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ContainerQueryType> as VisitMutWith<V>>::visit_mut_with(queries, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryAnd {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_and`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_query_and(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryAnd {
+    #[doc = "Calls [VisitMut`::visit_mut_container_query_and`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_query_and(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContainerQueryAnd {
                 span,
@@ -66333,48 +46712,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryAnd {
                 query,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
-                        self::fields::ContainerQueryAndField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
-                        self::fields::ContainerQueryAndField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
-                        self::fields::ContainerQueryAndField::Query,
-                    ));
-                    <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QueryInParens as VisitMutWith<V>>::visit_mut_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryNot {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_not`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_query_not(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryNot {
+    #[doc = "Calls [VisitMut`::visit_mut_container_query_not`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_query_not(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContainerQueryNot {
                 span,
@@ -66382,48 +46738,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryNot {
                 query,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
-                        self::fields::ContainerQueryNotField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
-                        self::fields::ContainerQueryNotField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
-                        self::fields::ContainerQueryNotField::Query,
-                    ));
-                    <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QueryInParens as VisitMutWith<V>>::visit_mut_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryOr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_or`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_query_or(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryOr {
+    #[doc = "Calls [VisitMut`::visit_mut_container_query_or`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_query_or(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContainerQueryOr {
                 span,
@@ -66431,361 +46764,175 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryOr {
                 query,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
-                        self::fields::ContainerQueryOrField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
-                        self::fields::ContainerQueryOrField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
-                        self::fields::ContainerQueryOrField::Query,
-                    ));
-                    <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QueryInParens as VisitMutWith<V>>::visit_mut_with(query, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_query_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContainerQueryType {
+    #[doc = "Calls [VisitMut`::visit_mut_container_query_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_query_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContainerQueryType::Not { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::Not,
-                ));
-                <ContainerQueryNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContainerQueryNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ContainerQueryType::And { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::And,
-                ));
-                <ContainerQueryAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContainerQueryAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ContainerQueryType::Or { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::Or,
-                ));
-                <ContainerQueryOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContainerQueryOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ContainerQueryType::QueryInParens { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::QueryInParens,
-                ));
-                <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <QueryInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomHighlightName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_highlight_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_highlight_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomHighlightName {
+    #[doc = "Calls [VisitMut`::visit_mut_custom_highlight_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_custom_highlight_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CustomHighlightName { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
-                        self::fields::CustomHighlightNameField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
-                        self::fields::CustomHighlightNameField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
-                        self::fields::CustomHighlightNameField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomIdent {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_ident`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_ident(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomIdent {
+    #[doc = "Calls [VisitMut`::visit_mut_custom_ident`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_custom_ident(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CustomIdent { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
-                        self::fields::CustomIdentField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
-                        self::fields::CustomIdentField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
-                        self::fields::CustomIdentField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomMediaQuery {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_media_query`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_media_query(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomMediaQuery {
+    #[doc = "Calls [VisitMut`::visit_mut_custom_media_query`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_custom_media_query(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CustomMediaQuery { span, name, media } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
-                        self::fields::CustomMediaQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
-                        self::fields::CustomMediaQueryField::Name,
-                    ));
-                    <ExtensionName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ExtensionName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
-                        self::fields::CustomMediaQueryField::Media,
-                    ));
-                    <CustomMediaQueryMediaType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        media,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <CustomMediaQueryMediaType as VisitMutWith<V>>::visit_mut_with(media, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomMediaQueryMediaType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_media_query_media_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomMediaQueryMediaType {
+    #[doc = "Calls [VisitMut`::visit_mut_custom_media_query_media_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_custom_media_query_media_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CustomMediaQueryMediaType::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
-                        self::fields::CustomMediaQueryMediaTypeField::Ident,
-                    ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
-                        self::fields::CustomMediaQueryMediaTypeField::MediaQueryList,
-                    ));
-                <MediaQueryList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaQueryList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomPropertyName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_property_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_property_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CustomPropertyName {
+    #[doc = "Calls [VisitMut`::visit_mut_custom_property_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_custom_property_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CustomPropertyName { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
-                        self::fields::CustomPropertyNameField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
-                        self::fields::CustomPropertyNameField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
-                        self::fields::CustomPropertyNameField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DashedIdent {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_dashed_ident`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_dashed_ident(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DashedIdent {
+    #[doc = "Calls [VisitMut`::visit_mut_dashed_ident`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_dashed_ident(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DashedIdent { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
-                        self::fields::DashedIdentField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
-                        self::fields::DashedIdentField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
-                        self::fields::DashedIdentField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Declaration {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_declaration`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_declaration(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Declaration {
+    #[doc = "Calls [VisitMut`::visit_mut_declaration`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_declaration(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Declaration {
                 span,
@@ -66794,168 +46941,84 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Declaration {
                 important,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Name,
-                    ));
-                    <DeclarationName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <DeclarationName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Important,
-                    ));
-                    <Option<ImportantFlag> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        important,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ImportantFlag> as VisitMutWith<V>>::visit_mut_with(important, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DeclarationName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_declaration_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_declaration_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DeclarationName {
+    #[doc = "Calls [VisitMut`::visit_mut_declaration_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_declaration_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DeclarationName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
-                    self::fields::DeclarationNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             DeclarationName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
-                    self::fields::DeclarationNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DeclarationOrAtRule {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_declaration_or_at_rule`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DeclarationOrAtRule {
+    #[doc = "Calls [VisitMut`::visit_mut_declaration_or_at_rule`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_declaration_or_at_rule(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DeclarationOrAtRule::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
-                    self::fields::DeclarationOrAtRuleField::Declaration,
-                ));
-                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             DeclarationOrAtRule::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
-                    self::fields::DeclarationOrAtRuleField::AtRule,
-                ));
-                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
-                    self::fields::DeclarationOrAtRuleField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Delimiter {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_delimiter`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_delimiter(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Delimiter {
+    #[doc = "Calls [VisitMut`::visit_mut_delimiter`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_delimiter(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Delimiter { span, value } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Delimiter(self::fields::DelimiterField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Delimiter(
-                        self::fields::DelimiterField::Value,
-                    ));
-                    <DelimiterValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <DelimiterValue as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DelimiterValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_delimiter_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_delimiter_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DelimiterValue {
+    #[doc = "Calls [VisitMut`::visit_mut_delimiter_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_delimiter_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DelimiterValue::Comma => {}
             DelimiterValue::Solidus => {}
@@ -66963,96 +47026,45 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DelimiterValue {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Dimension {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_dimension`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_dimension(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Dimension {
+    #[doc = "Calls [VisitMut`::visit_mut_dimension`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_dimension(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Dimension::Length { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Length,
-                ));
-                <Length as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Length as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Dimension::Angle { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Angle,
-                ));
-                <Angle as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Angle as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Dimension::Time { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Time));
-                <Time as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Time as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Dimension::Frequency { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Frequency,
-                ));
-                <Frequency as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Frequency as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Dimension::Resolution { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Resolution,
-                ));
-                <Resolution as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Resolution as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Dimension::Flex { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Flex));
-                <Flex as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Flex as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Dimension::UnknownDimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::UnknownDimension,
-                ));
-                <UnknownDimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UnknownDimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DimensionToken {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_dimension_token`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_dimension_token(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DimensionToken {
+    #[doc = "Calls [VisitMut`::visit_mut_dimension_token`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_dimension_token(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DimensionToken {
                 value,
@@ -67062,759 +47074,401 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DimensionToken {
                 raw_unit,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::RawValue,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw_value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw_value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::Unit,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::TypeFlag,
-                    ));
-                    <NumberType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_flag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <NumberType as VisitMutWith<V>>::visit_mut_with(type_flag, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::RawUnit,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw_unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw_unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DocumentPrelude {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_document_prelude`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DocumentPrelude {
+    #[doc = "Calls [VisitMut`::visit_mut_document_prelude`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_document_prelude(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DocumentPrelude {
                 span,
                 matching_functions,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
-                        self::fields::DocumentPreludeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
-                        self::fields::DocumentPreludeField::MatchingFunctions(usize::MAX),
-                    ));
-                    < Vec < DocumentPreludeMatchingFunction > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (matching_functions , visitor , & mut * __ast_path)
+                    <Vec<DocumentPreludeMatchingFunction> as VisitMutWith<V>>::visit_mut_with(
+                        matching_functions,
+                        visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DocumentPreludeMatchingFunction {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_document_prelude_matching_function`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
-            visitor, self, __ast_path,
-        )
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DocumentPreludeMatchingFunction {
+    #[doc = "Calls [VisitMut`::visit_mut_document_prelude_matching_function`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_document_prelude_matching_function(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DocumentPreludeMatchingFunction::Url { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
-                        self::fields::DocumentPreludeMatchingFunctionField::Url,
-                    ));
-                <Url as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Url as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             DocumentPreludeMatchingFunction::Function { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
-                        self::fields::DocumentPreludeMatchingFunctionField::Function,
-                    ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExtensionName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_extension_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_extension_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExtensionName {
+    #[doc = "Calls [VisitMut`::visit_mut_extension_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_extension_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExtensionName { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
-                        self::fields::ExtensionNameField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
-                        self::fields::ExtensionNameField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
-                        self::fields::ExtensionNameField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FamilyName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_family_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_family_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for FamilyName {
+    #[doc = "Calls [VisitMut`::visit_mut_family_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_family_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             FamilyName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
-                    self::fields::FamilyNameField::Str,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             FamilyName::SequenceOfCustomIdents { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
-                    self::fields::FamilyNameField::SequenceOfCustomIdents,
-                ));
-                <SequenceOfCustomIdents as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SequenceOfCustomIdents as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Flex {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_flex`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_flex(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Flex {
+    #[doc = "Calls [VisitMut`::visit_mut_flex`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_flex(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Flex { span, value, unit } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Value));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Unit));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FontFeatureValuesPrelude {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_font_feature_values_prelude`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for FontFeatureValuesPrelude {
+    #[doc = "Calls [VisitMut`::visit_mut_font_feature_values_prelude`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_font_feature_values_prelude(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             FontFeatureValuesPrelude { span, font_family } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
-                            self::fields::FontFeatureValuesPreludeField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
-                            self::fields::FontFeatureValuesPreludeField::FontFamily(usize::MAX),
-                        ));
-                    <Vec<FamilyName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        font_family,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<FamilyName> as VisitMutWith<V>>::visit_mut_with(font_family, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingComplexSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_complex_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingComplexSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_forgiving_complex_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_forgiving_complex_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForgivingComplexSelector::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
-                        self::fields::ForgivingComplexSelectorField::ComplexSelector,
-                    ));
-                <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComplexSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
-                        self::fields::ForgivingComplexSelectorField::ListOfComponentValues,
-                    ));
-                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingRelativeSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_relative_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingRelativeSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_forgiving_relative_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_forgiving_relative_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForgivingRelativeSelector::RelativeSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
-                        self::fields::ForgivingRelativeSelectorField::RelativeSelector,
-                    ));
-                <RelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RelativeSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
-                        self::fields::ForgivingRelativeSelectorField::ListOfComponentValues,
-                    ));
-                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingRelativeSelectorList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_relative_selector_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
-            visitor, self, __ast_path,
-        )
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingRelativeSelectorList {
+    #[doc = "Calls [VisitMut`::visit_mut_forgiving_relative_selector_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_forgiving_relative_selector_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForgivingRelativeSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
-                            self::fields::ForgivingRelativeSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
-                            self::fields::ForgivingRelativeSelectorListField::Children(usize::MAX),
-                        ));
-                    < Vec < ForgivingRelativeSelector > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Vec<ForgivingRelativeSelector> as VisitMutWith<V>>::visit_mut_with(
+                        children, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingSelectorList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_selector_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForgivingSelectorList {
+    #[doc = "Calls [VisitMut`::visit_mut_forgiving_selector_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_forgiving_selector_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForgivingSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
-                            self::fields::ForgivingSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
-                            self::fields::ForgivingSelectorListField::Children(usize::MAX),
-                        ));
-                    < Vec < ForgivingComplexSelector > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Vec<ForgivingComplexSelector> as VisitMutWith<V>>::visit_mut_with(
+                        children, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Frequency {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_frequency`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_frequency(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Frequency {
+    #[doc = "Calls [VisitMut`::visit_mut_frequency`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_frequency(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Frequency { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Frequency(
-                        self::fields::FrequencyField::Value,
-                    ));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Unit));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FrequencyPercentage {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_frequency_percentage`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_frequency_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for FrequencyPercentage {
+    #[doc = "Calls [VisitMut`::visit_mut_frequency_percentage`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_frequency_percentage(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             FrequencyPercentage::Frequency { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
-                    self::fields::FrequencyPercentageField::Frequency,
-                ));
-                <Frequency as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Frequency as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             FrequencyPercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
-                    self::fields::FrequencyPercentageField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Function {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_function`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Function {
+    #[doc = "Calls [VisitMut`::visit_mut_function`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_function(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Function { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Name));
-                    <FunctionName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <FunctionName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FunctionName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_function_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for FunctionName {
+    #[doc = "Calls [VisitMut`::visit_mut_function_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_function_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             FunctionName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
-                    self::fields::FunctionNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             FunctionName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
-                    self::fields::FunctionNameField::DashedIdent,
-                ));
-                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DashedIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for GeneralEnclosed {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_general_enclosed`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_general_enclosed(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for GeneralEnclosed {
+    #[doc = "Calls [VisitMut`::visit_mut_general_enclosed`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_general_enclosed(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             GeneralEnclosed::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
-                    self::fields::GeneralEnclosedField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             GeneralEnclosed::SimpleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
-                    self::fields::GeneralEnclosedField::SimpleBlock,
-                ));
-                <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SimpleBlock as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for HexColor {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_hex_color`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_hex_color(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for HexColor {
+    #[doc = "Calls [VisitMut`::visit_mut_hex_color`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_hex_color(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             HexColor { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Hue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_hue`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_hue(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Hue {
+    #[doc = "Calls [VisitMut`::visit_mut_hue`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_hue(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Hue::Number { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Number));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Hue::Angle { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Angle));
-                <Angle as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Angle as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for IdSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_id_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_id_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for IdSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_id_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_id_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             IdSelector { span, text } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
-                        self::fields::IdSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
-                        self::fields::IdSelectorField::Text,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        text,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(text, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Ident {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ident`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Ident {
+    #[doc = "Calls [VisitMut`::visit_mut_ident`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ident(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Ident { span, value, raw } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Ident(self::fields::IdentField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportConditions {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_conditions`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_conditions(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportConditions {
+    #[doc = "Calls [VisitMut`::visit_mut_import_conditions`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_conditions(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportConditions {
                 span,
@@ -67822,114 +47476,59 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportConditions {
                 media,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
-                        self::fields::ImportConditionsField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
-                        self::fields::ImportConditionsField::Supports,
-                    ));
-                    <Option<Box<Function>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        supports,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Function>> as VisitMutWith<V>>::visit_mut_with(supports, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
-                        self::fields::ImportConditionsField::Media,
-                    ));
-                    <Option<Box<MediaQueryList>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        media,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<MediaQueryList>> as VisitMutWith<V>>::visit_mut_with(media, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportHref {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_href`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_href(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportHref {
+    #[doc = "Calls [VisitMut`::visit_mut_import_href`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_href(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportHref::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
-                    self::fields::ImportHrefField::Url,
-                ));
-                <Url as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Url as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ImportHref::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
-                    self::fields::ImportHrefField::Str,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportLayerName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_layer_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_layer_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportLayerName {
+    #[doc = "Calls [VisitMut`::visit_mut_import_layer_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_layer_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportLayerName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
-                    self::fields::ImportLayerNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ImportLayerName::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
-                    self::fields::ImportLayerNameField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportPrelude {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_prelude`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportPrelude {
+    #[doc = "Calls [VisitMut`::visit_mut_import_prelude`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_prelude(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportPrelude {
                 span,
@@ -67938,118 +47537,71 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportPrelude {
                 import_conditions,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::Href,
-                    ));
-                    <Box<ImportHref> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        href,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<ImportHref> as VisitMutWith<V>>::visit_mut_with(href, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::LayerName,
-                    ));
-                    < Option < Box < ImportLayerName > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (layer_name , visitor , & mut * __ast_path)
+                    <Option<Box<ImportLayerName>> as VisitMutWith<V>>::visit_mut_with(
+                        layer_name, visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::ImportConditions,
-                    ));
-                    < Option < Box < ImportConditions > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (import_conditions , visitor , & mut * __ast_path)
-                };
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportantFlag {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_important_flag`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_important_flag(visitor, self, __ast_path)
+                    <Option<Box<ImportConditions>> as VisitMutWith<V>>::visit_mut_with(
+                        import_conditions,
+                        visitor,
+                    )
+                };
+            }
+        }
+    }
+}
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportantFlag {
+    #[doc = "Calls [VisitMut`::visit_mut_important_flag`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_important_flag(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportantFlag { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
-                        self::fields::ImportantFlagField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
-                        self::fields::ImportantFlagField::Value,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Integer {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_integer`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_integer(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Integer {
+    #[doc = "Calls [VisitMut`::visit_mut_integer`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_integer(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Integer { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframeBlock {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframe_block`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_block(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframeBlock {
+    #[doc = "Calls [VisitMut`::visit_mut_keyframe_block`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_keyframe_block(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             KeyframeBlock {
                 span,
@@ -68057,444 +47609,224 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframeBlock {
                 block,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
-                        self::fields::KeyframeBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
-                        self::fields::KeyframeBlockField::Prelude(usize::MAX),
-                    ));
-                    <Vec<KeyframeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<KeyframeSelector> as VisitMutWith<V>>::visit_mut_with(prelude, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
-                        self::fields::KeyframeBlockField::Block,
-                    ));
-                    <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SimpleBlock as VisitMutWith<V>>::visit_mut_with(block, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframeSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframe_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframeSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_keyframe_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_keyframe_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             KeyframeSelector::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
-                    self::fields::KeyframeSelectorField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             KeyframeSelector::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
-                    self::fields::KeyframeSelectorField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframesName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframes_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframesName {
+    #[doc = "Calls [VisitMut`::visit_mut_keyframes_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_keyframes_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             KeyframesName::CustomIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::CustomIdent,
-                ));
-                <Box<CustomIdent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<CustomIdent> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             KeyframesName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::Str,
-                ));
-                <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Str> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             KeyframesName::PseudoPrefix { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::PseudoPrefix,
-                ));
-                <Box<KeyframesPseudoPrefix> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<KeyframesPseudoPrefix> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             KeyframesName::PseudoFunction { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::PseudoFunction,
-                ));
-                <Box<KeyframesPseudoFunction> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
+                <Box<KeyframesPseudoFunction> as VisitMutWith<V>>::visit_mut_with(
+                    _field_0, visitor,
                 );
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframesPseudoFunction {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframes_pseudo_function`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframesPseudoFunction {
+    #[doc = "Calls [VisitMut`::visit_mut_keyframes_pseudo_function`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_keyframes_pseudo_function(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             KeyframesPseudoFunction { span, pseudo, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
-                            self::fields::KeyframesPseudoFunctionField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
-                            self::fields::KeyframesPseudoFunctionField::Pseudo,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        pseudo,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(pseudo, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
-                            self::fields::KeyframesPseudoFunctionField::Name,
-                        ));
-                    <KeyframesName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <KeyframesName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframesPseudoPrefix {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframes_pseudo_prefix`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyframesPseudoPrefix {
+    #[doc = "Calls [VisitMut`::visit_mut_keyframes_pseudo_prefix`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_keyframes_pseudo_prefix(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             KeyframesPseudoPrefix { span, pseudo, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
-                            self::fields::KeyframesPseudoPrefixField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
-                            self::fields::KeyframesPseudoPrefixField::Pseudo,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        pseudo,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(pseudo, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
-                            self::fields::KeyframesPseudoPrefixField::Name,
-                        ));
-                    <KeyframesName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <KeyframesName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LayerName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for LayerName {
+    #[doc = "Calls [VisitMut`::visit_mut_layer_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_layer_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             LayerName { span, name } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::LayerName(self::fields::LayerNameField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerName(
-                        self::fields::LayerNameField::Name(usize::MAX),
-                    ));
-                    <Vec<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Ident> as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LayerNameList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_name_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_name_list(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for LayerNameList {
+    #[doc = "Calls [VisitMut`::visit_mut_layer_name_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_layer_name_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             LayerNameList { span, name_list } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
-                        self::fields::LayerNameListField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
-                        self::fields::LayerNameListField::NameList(usize::MAX),
-                    ));
-                    <Vec<LayerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name_list,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<LayerName> as VisitMutWith<V>>::visit_mut_with(name_list, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LayerPrelude {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_prelude`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for LayerPrelude {
+    #[doc = "Calls [VisitMut`::visit_mut_layer_prelude`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_layer_prelude(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             LayerPrelude::Name { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
-                    self::fields::LayerPreludeField::Name,
-                ));
-                <LayerName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <LayerName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             LayerPrelude::NameList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
-                    self::fields::LayerPreludeField::NameList,
-                ));
-                <LayerNameList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <LayerNameList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Length {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_length`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_length(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Length {
+    #[doc = "Calls [VisitMut`::visit_mut_length`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_length(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Length { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Length(self::fields::LengthField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Length(self::fields::LengthField::Value));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Length(self::fields::LengthField::Unit));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LengthPercentage {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_length_percentage`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_length_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for LengthPercentage {
+    #[doc = "Calls [VisitMut`::visit_mut_length_percentage`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_length_percentage(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             LengthPercentage::Length { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
-                    self::fields::LengthPercentageField::Length,
-                ));
-                <Length as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Length as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             LengthPercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
-                    self::fields::LengthPercentageField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ListOfComponentValues {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_list_of_component_values`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_list_of_component_values(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ListOfComponentValues {
+    #[doc = "Calls [VisitMut`::visit_mut_list_of_component_values`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_list_of_component_values(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ListOfComponentValues { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
-                            self::fields::ListOfComponentValuesField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
-                            self::fields::ListOfComponentValuesField::Children(usize::MAX),
-                        ));
-                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaAnd {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_and`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_and(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaAnd {
+    #[doc = "Calls [VisitMut`::visit_mut_media_and`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_and(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaAnd {
                 span,
@@ -68502,413 +47834,208 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaAnd {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaAnd(self::fields::MediaAndField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
-                        self::fields::MediaAndField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
-                        self::fields::MediaAndField::Condition,
-                    ));
-                    <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaInParens as VisitMutWith<V>>::visit_mut_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaCondition {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_condition(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaCondition {
+    #[doc = "Calls [VisitMut`::visit_mut_media_condition`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_condition(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaCondition { span, conditions } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
-                        self::fields::MediaConditionField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
-                        self::fields::MediaConditionField::Conditions(usize::MAX),
-                    ));
-                    <Vec<MediaConditionAllType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
+                    <Vec<MediaConditionAllType> as VisitMutWith<V>>::visit_mut_with(
+                        conditions, visitor,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionAllType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_all_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_all_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionAllType {
+    #[doc = "Calls [VisitMut`::visit_mut_media_condition_all_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_condition_all_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaConditionAllType::Not { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::Not,
-                ));
-                <MediaNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaConditionAllType::And { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::And,
-                ));
-                <MediaAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaConditionAllType::Or { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::Or,
-                ));
-                <MediaOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaConditionAllType::MediaInParens { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::MediaInParens,
-                ));
-                <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionType {
+    #[doc = "Calls [VisitMut`::visit_mut_media_condition_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_condition_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaConditionType::All { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
-                    self::fields::MediaConditionTypeField::All,
-                ));
-                <MediaCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaConditionType::WithoutOr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
-                    self::fields::MediaConditionTypeField::WithoutOr,
-                ));
-                <MediaConditionWithoutOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaConditionWithoutOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionWithoutOr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_without_or`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionWithoutOr {
+    #[doc = "Calls [VisitMut`::visit_mut_media_condition_without_or`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_condition_without_or(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaConditionWithoutOr { span, conditions } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
-                            self::fields::MediaConditionWithoutOrField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
-                            self::fields::MediaConditionWithoutOrField::Conditions(usize::MAX),
-                        ));
-                    < Vec < MediaConditionWithoutOrType > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (conditions , visitor , & mut * __ast_path)
+                    <Vec<MediaConditionWithoutOrType> as VisitMutWith<V>>::visit_mut_with(
+                        conditions, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionWithoutOrType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_without_or_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaConditionWithoutOrType {
+    #[doc = "Calls [VisitMut`::visit_mut_media_condition_without_or_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_condition_without_or_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaConditionWithoutOrType::Not { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
-                        self::fields::MediaConditionWithoutOrTypeField::Not,
-                    ));
-                <MediaNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaConditionWithoutOrType::And { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
-                        self::fields::MediaConditionWithoutOrTypeField::And,
-                    ));
-                <MediaAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaConditionWithoutOrType::MediaInParens { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
-                        self::fields::MediaConditionWithoutOrTypeField::MediaInParens,
-                    ));
-                <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeature {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeature::Plain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::Plain,
-                ));
-                <MediaFeaturePlain as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeaturePlain as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeature::Boolean { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::Boolean,
-                ));
-                <MediaFeatureBoolean as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeatureBoolean as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeature::Range { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::Range,
-                ));
-                <MediaFeatureRange as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeatureRange as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeature::RangeInterval { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::RangeInterval,
-                ));
-                <MediaFeatureRangeInterval as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MediaFeatureRangeInterval as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureBoolean {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_boolean`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_boolean(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureBoolean {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature_boolean`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature_boolean(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeatureBoolean { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
-                        self::fields::MediaFeatureBooleanField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
-                        self::fields::MediaFeatureBooleanField::Name,
-                    ));
-                    <MediaFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureName {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeatureName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
-                    self::fields::MediaFeatureNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeatureName::ExtensionName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
-                    self::fields::MediaFeatureNameField::ExtensionName,
-                ));
-                <ExtensionName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExtensionName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeaturePlain {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_plain`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_plain(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeaturePlain {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature_plain`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature_plain(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeaturePlain { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
-                        self::fields::MediaFeaturePlainField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
-                        self::fields::MediaFeaturePlainField::Name,
-                    ));
-                    <MediaFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
-                        self::fields::MediaFeaturePlainField::Value,
-                    ));
-                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRange {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_range`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRange {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature_range`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature_range(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeatureRange {
                 span,
@@ -68917,58 +48044,30 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRange {
                 right,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Left,
-                    ));
-                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Comparison,
-                    ));
-                    <MediaFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        comparison,
-                        visitor,
-                        &mut *__ast_path,
+                    <MediaFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
+                        comparison, visitor,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Right,
-                    ));
-                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRangeComparison {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_range_comparison`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRangeComparison {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature_range_comparison`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature_range_comparison(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeatureRangeComparison::Lt => {}
             MediaFeatureRangeComparison::Le => {}
@@ -68978,15 +48077,13 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRangeCo
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRangeInterval {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_range_interval`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureRangeInterval {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature_range_interval`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature_range_interval(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeatureRangeInterval {
                 span,
@@ -68997,190 +48094,86 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRangeIn
                 right,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Left,
-                        ));
-                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::LeftComparison,
-                        ));
-                    <MediaFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <MediaFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
                         left_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Name,
-                        ));
-                    <MediaFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::RightComparison,
-                        ));
-                    <MediaFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <MediaFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
                         right_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Right,
-                        ));
-                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<MediaFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_feature_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaFeatureValue {
+    #[doc = "Calls [VisitMut`::visit_mut_media_feature_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_feature_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaFeatureValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Number,
-                ));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeatureValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Dimension,
-                ));
-                <Dimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Dimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeatureValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeatureValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Ratio,
-                ));
-                <Ratio as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ratio as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaFeatureValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaInParens {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_in_parens`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaInParens {
+    #[doc = "Calls [VisitMut`::visit_mut_media_in_parens`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_in_parens(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            MediaInParens::MediaCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
-                    self::fields::MediaInParensField::MediaCondition,
-                ));
-                <MediaCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            MediaInParens::Feature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
-                    self::fields::MediaInParensField::Feature,
-                ));
-                <Box<MediaFeature> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+            MediaInParens::MediaCondition { 0: _field_0 } => {
+                <MediaCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+            }
+            MediaInParens::Feature { 0: _field_0 } => {
+                <Box<MediaFeature> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MediaInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
-                    self::fields::MediaInParensField::GeneralEnclosed,
-                ));
-                <GeneralEnclosed as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GeneralEnclosed as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaNot {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_not`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_not(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaNot {
+    #[doc = "Calls [VisitMut`::visit_mut_media_not`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_not(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaNot {
                 span,
@@ -69188,47 +48181,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaNot {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaNot(self::fields::MediaNotField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
-                        self::fields::MediaNotField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
-                        self::fields::MediaNotField::Condition,
-                    ));
-                    <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaInParens as VisitMutWith<V>>::visit_mut_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaOr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_or`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_or(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaOr {
+    #[doc = "Calls [VisitMut`::visit_mut_media_or`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_or(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaOr {
                 span,
@@ -69236,46 +48207,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaOr {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Keyword));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaOr(
-                        self::fields::MediaOrField::Condition,
-                    ));
-                    <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaInParens as VisitMutWith<V>>::visit_mut_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaQuery {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_query`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_query(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaQuery {
+    #[doc = "Calls [VisitMut`::visit_mut_media_query`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_query(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaQuery {
                 span,
@@ -69285,375 +48235,208 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaQuery {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Modifier,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        modifier,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(modifier, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::MediaType,
-                    ));
-                    <Option<MediaType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        media_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<MediaType> as VisitMutWith<V>>::visit_mut_with(media_type, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Condition,
-                    ));
-                    < Option < Box < MediaConditionType > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (condition , visitor , & mut * __ast_path)
+                    <Option<Box<MediaConditionType>> as VisitMutWith<V>>::visit_mut_with(
+                        condition, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaQueryList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_query_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_query_list(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaQueryList {
+    #[doc = "Calls [VisitMut`::visit_mut_media_query_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_query_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaQueryList { span, queries } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
-                        self::fields::MediaQueryListField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
-                        self::fields::MediaQueryListField::Queries(usize::MAX),
-                    ));
-                    <Vec<MediaQuery> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        queries,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<MediaQuery> as VisitMutWith<V>>::visit_mut_with(queries, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MediaType {
+    #[doc = "Calls [VisitMut`::visit_mut_media_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MediaType::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaType(
-                    self::fields::MediaTypeField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamedNamespace {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_named_namespace`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_named_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamedNamespace {
+    #[doc = "Calls [VisitMut`::visit_mut_named_namespace`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_named_namespace(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NamedNamespace { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
-                        self::fields::NamedNamespaceField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
-                        self::fields::NamedNamespaceField::Name,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Namespace {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Namespace {
+    #[doc = "Calls [VisitMut`::visit_mut_namespace`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_namespace(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Namespace::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Namespace(
-                    self::fields::NamespaceField::Named,
-                ));
-                <NamedNamespace as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NamedNamespace as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Namespace::Any { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Namespace(self::fields::NamespaceField::Any));
-                <AnyNamespace as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AnyNamespace as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamespacePrefix {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace_prefix`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prefix(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamespacePrefix {
+    #[doc = "Calls [VisitMut`::visit_mut_namespace_prefix`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_namespace_prefix(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NamespacePrefix { span, namespace } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
-                        self::fields::NamespacePrefixField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
-                        self::fields::NamespacePrefixField::Namespace,
-                    ));
-                    <Option<Namespace> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        namespace,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Namespace> as VisitMutWith<V>>::visit_mut_with(namespace, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamespacePrelude {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace_prelude`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamespacePrelude {
+    #[doc = "Calls [VisitMut`::visit_mut_namespace_prelude`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_namespace_prelude(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NamespacePrelude { span, prefix, uri } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
-                        self::fields::NamespacePreludeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
-                        self::fields::NamespacePreludeField::Prefix,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(prefix, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
-                        self::fields::NamespacePreludeField::Uri,
-                    ));
-                    <Box<NamespacePreludeUri> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        uri,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<NamespacePreludeUri> as VisitMutWith<V>>::visit_mut_with(uri, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamespacePreludeUri {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace_prelude_uri`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamespacePreludeUri {
+    #[doc = "Calls [VisitMut`::visit_mut_namespace_prelude_uri`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_namespace_prelude_uri(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NamespacePreludeUri::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
-                    self::fields::NamespacePreludeUriField::Url,
-                ));
-                <Url as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Url as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             NamespacePreludeUri::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
-                    self::fields::NamespacePreludeUriField::Str,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NestingSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_nesting_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_nesting_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NestingSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_nesting_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_nesting_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NestingSelector { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NestingSelector(
-                        self::fields::NestingSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Number {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_number`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Number {
+    #[doc = "Calls [VisitMut`::visit_mut_number`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_number(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Number { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NumberType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_number_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NumberType {
+    #[doc = "Calls [VisitMut`::visit_mut_number_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_number_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NumberType::Integer => {}
             NumberType::Number => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_page_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_page_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PageSelector {
                 span,
@@ -69661,184 +48444,105 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelector {
                 pseudos,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
-                        self::fields::PageSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
-                        self::fields::PageSelectorField::PageType,
-                    ));
-                    <Option<PageSelectorType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        page_type,
-                        visitor,
-                        &mut *__ast_path,
+                    <Option<PageSelectorType> as VisitMutWith<V>>::visit_mut_with(
+                        page_type, visitor,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
-                        self::fields::PageSelectorField::Pseudos(usize::MAX),
-                    ));
-                    < Option < Vec < PageSelectorPseudo > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (pseudos , visitor , & mut * __ast_path)
+                    <Option<Vec<PageSelectorPseudo>> as VisitMutWith<V>>::visit_mut_with(
+                        pseudos, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelectorList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelectorList {
+    #[doc = "Calls [VisitMut`::visit_mut_page_selector_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_page_selector_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PageSelectorList { span, selectors } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
-                        self::fields::PageSelectorListField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
-                        self::fields::PageSelectorListField::Selectors(usize::MAX),
-                    ));
-                    <Vec<PageSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        selectors,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<PageSelector> as VisitMutWith<V>>::visit_mut_with(selectors, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelectorPseudo {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_pseudo`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelectorPseudo {
+    #[doc = "Calls [VisitMut`::visit_mut_page_selector_pseudo`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_page_selector_pseudo(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PageSelectorPseudo { span, value } => {
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
-                        self::fields::PageSelectorPseudoField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
-                        self::fields::PageSelectorPseudoField::Value,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                {
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                };
+                {
+                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelectorType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PageSelectorType {
+    #[doc = "Calls [VisitMut`::visit_mut_page_selector_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_page_selector_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PageSelectorType { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
-                        self::fields::PageSelectorTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
-                        self::fields::PageSelectorTypeField::Value,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Percentage {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_percentage`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Percentage {
+    #[doc = "Calls [VisitMut`::visit_mut_percentage`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_percentage(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Percentage { span, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
-                        self::fields::PercentageField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
-                        self::fields::PercentageField::Value,
-                    ));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoClassSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_class_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoClassSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_pseudo_class_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pseudo_class_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PseudoClassSelector {
                 span,
@@ -69846,189 +48550,76 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoClassSelector
                 children,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
-                        self::fields::PseudoClassSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
-                        self::fields::PseudoClassSelectorField::Name,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
-                        self::fields::PseudoClassSelectorField::Children(usize::MAX),
-                    ));
-                    < Option < Vec < PseudoClassSelectorChildren > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Option<Vec<PseudoClassSelectorChildren>> as VisitMutWith<V>>::visit_mut_with(
+                        children, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoClassSelectorChildren {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_class_selector_children`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoClassSelectorChildren {
+    #[doc = "Calls [VisitMut`::visit_mut_pseudo_class_selector_children`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pseudo_class_selector_children(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PseudoClassSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::PreservedToken,
-                    ));
-                <TokenAndSpan as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TokenAndSpan as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::AnPlusB { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::AnPlusB,
-                    ));
-                <AnPlusB as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AnPlusB as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::Ident,
-                    ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::Str,
-                    ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::Delimiter,
-                    ));
-                <Delimiter as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Delimiter as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::ComplexSelector,
-                    ));
-                <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComplexSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::SelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::SelectorList,
-                    ));
-                <SelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::ForgivingSelectorList,
-                    ));
-                <ForgivingSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForgivingSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::CompoundSelectorList,
-                    ));
-                <CompoundSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::RelativeSelectorList,
-                    ));
-                <RelativeSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RelativeSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PseudoClassSelectorChildren(
-                    self::fields::PseudoClassSelectorChildrenField::ForgivingRelativeSelectorList,
-                ));
-                <ForgivingRelativeSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
+                <ForgivingRelativeSelectorList as VisitMutWith<V>>::visit_mut_with(
+                    _field_0, visitor,
                 );
             }
             PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::CompoundSelector,
-                    ));
-                <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoElementSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_element_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoElementSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_pseudo_element_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pseudo_element_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PseudoElementSelector {
                 span,
@@ -70036,106 +48627,50 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoElementSelect
                 children,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
-                            self::fields::PseudoElementSelectorField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
-                            self::fields::PseudoElementSelectorField::Name,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
-                            self::fields::PseudoElementSelectorField::Children(usize::MAX),
-                        ));
-                    < Option < Vec < PseudoElementSelectorChildren > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Option<Vec<PseudoElementSelectorChildren>> as VisitMutWith<V>>::visit_mut_with(
+                        children, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoElementSelectorChildren {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_element_selector_children`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
-            visitor, self, __ast_path,
-        )
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PseudoElementSelectorChildren {
+    #[doc = "Calls [VisitMut`::visit_mut_pseudo_element_selector_children`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pseudo_element_selector_children(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PseudoElementSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::PreservedToken,
-                    ));
-                <TokenAndSpan as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TokenAndSpan as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::Ident,
-                    ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::CompoundSelector,
-                    ));
-                <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CompoundSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::CustomHighlightName,
-                    ));
-                <CustomHighlightName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CustomHighlightName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for QualifiedRule {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_qualified_rule`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_qualified_rule(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for QualifiedRule {
+    #[doc = "Calls [VisitMut`::visit_mut_qualified_rule`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_qualified_rule(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             QualifiedRule {
                 span,
@@ -70143,348 +48678,174 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for QualifiedRule {
                 block,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
-                        self::fields::QualifiedRuleField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
-                        self::fields::QualifiedRuleField::Prelude,
-                    ));
-                    <QualifiedRulePrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <QualifiedRulePrelude as VisitMutWith<V>>::visit_mut_with(prelude, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
-                        self::fields::QualifiedRuleField::Block,
-                    ));
-                    <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SimpleBlock as VisitMutWith<V>>::visit_mut_with(block, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for QualifiedRulePrelude {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_qualified_rule_prelude`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for QualifiedRulePrelude {
+    #[doc = "Calls [VisitMut`::visit_mut_qualified_rule_prelude`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_qualified_rule_prelude(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             QualifiedRulePrelude::SelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
-                    self::fields::QualifiedRulePreludeField::SelectorList,
-                ));
-                <SelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
-                    self::fields::QualifiedRulePreludeField::RelativeSelectorList,
-                ));
-                <RelativeSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RelativeSelectorList as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
-                    self::fields::QualifiedRulePreludeField::ListOfComponentValues,
-                ));
-                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ListOfComponentValues as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for QueryInParens {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_query_in_parens`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_query_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for QueryInParens {
+    #[doc = "Calls [VisitMut`::visit_mut_query_in_parens`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_query_in_parens(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             QueryInParens::ContainerQuery { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
-                    self::fields::QueryInParensField::ContainerQuery,
-                ));
-                <Box<ContainerQuery> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ContainerQuery> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             QueryInParens::SizeFeature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
-                    self::fields::QueryInParensField::SizeFeature,
-                ));
-                <SizeFeature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             QueryInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
-                    self::fields::QueryInParensField::GeneralEnclosed,
-                ));
-                <GeneralEnclosed as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GeneralEnclosed as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Ratio {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ratio`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ratio(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Ratio {
+    #[doc = "Calls [VisitMut`::visit_mut_ratio`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ratio(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Ratio { span, left, right } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Left));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Ratio(self::fields::RatioField::Right));
-                    <Option<Number> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Number> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for RelativeSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_relative_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_relative_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for RelativeSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_relative_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_relative_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             RelativeSelector {
                 span,
                 combinator,
                 selector,
             } => {
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
-                        self::fields::RelativeSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
-                        self::fields::RelativeSelectorField::Combinator,
-                    ));
-                    <Option<Combinator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        combinator,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                {
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
-                        self::fields::RelativeSelectorField::Selector,
-                    ));
-                    <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        selector,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Combinator> as VisitMutWith<V>>::visit_mut_with(combinator, visitor)
+                };
+                {
+                    <ComplexSelector as VisitMutWith<V>>::visit_mut_with(selector, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for RelativeSelectorList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_relative_selector_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_relative_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for RelativeSelectorList {
+    #[doc = "Calls [VisitMut`::visit_mut_relative_selector_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_relative_selector_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             RelativeSelectorList { span, children } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
-                            self::fields::RelativeSelectorListField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
-                            self::fields::RelativeSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<RelativeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<RelativeSelector> as VisitMutWith<V>>::visit_mut_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Resolution {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_resolution`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_resolution(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Resolution {
+    #[doc = "Calls [VisitMut`::visit_mut_resolution`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_resolution(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Resolution { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
-                        self::fields::ResolutionField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
-                        self::fields::ResolutionField::Value,
-                    ));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
-                        self::fields::ResolutionField::Unit,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Rule {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_rule`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rule(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Rule {
+    #[doc = "Calls [VisitMut`::visit_mut_rule`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_rule(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Rule::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Rule(self::fields::RuleField::QualifiedRule));
-                <Box<QualifiedRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<QualifiedRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Rule::AtRule { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Rule(self::fields::RuleField::AtRule));
-                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Rule::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Rule(
-                    self::fields::RuleField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ScopeRange {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_scope_range`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_scope_range(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ScopeRange {
+    #[doc = "Calls [VisitMut`::visit_mut_scope_range`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_scope_range(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ScopeRange {
                 span,
@@ -70492,313 +48853,168 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ScopeRange {
                 scope_end,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
-                        self::fields::ScopeRangeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
-                        self::fields::ScopeRangeField::ScopeStart,
-                    ));
-                    < Option < ForgivingSelectorList > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (scope_start , visitor , & mut * __ast_path)
+                    <Option<ForgivingSelectorList> as VisitMutWith<V>>::visit_mut_with(
+                        scope_start,
+                        visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
-                        self::fields::ScopeRangeField::ScopeEnd,
-                    ));
-                    < Option < ForgivingSelectorList > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (scope_end , visitor , & mut * __ast_path)
+                    <Option<ForgivingSelectorList> as VisitMutWith<V>>::visit_mut_with(
+                        scope_end, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SelectorList {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_selector_list`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SelectorList {
+    #[doc = "Calls [VisitMut`::visit_mut_selector_list`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_selector_list(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SelectorList { span, children } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
-                        self::fields::SelectorListField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
-                        self::fields::SelectorListField::Children(usize::MAX),
-                    ));
-                    <Vec<ComplexSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComplexSelector> as VisitMutWith<V>>::visit_mut_with(children, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SequenceOfCustomIdents {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_sequence_of_custom_idents`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SequenceOfCustomIdents {
+    #[doc = "Calls [VisitMut`::visit_mut_sequence_of_custom_idents`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_sequence_of_custom_idents(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SequenceOfCustomIdents { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
-                            self::fields::SequenceOfCustomIdentsField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
-                            self::fields::SequenceOfCustomIdentsField::Value(usize::MAX),
-                        ));
-                    <Vec<CustomIdent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<CustomIdent> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SimpleBlock {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_simple_block`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_simple_block(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SimpleBlock {
+    #[doc = "Calls [VisitMut`::visit_mut_simple_block`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_simple_block(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SimpleBlock { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
-                        self::fields::SimpleBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
-                        self::fields::SimpleBlockField::Name,
-                    ));
-                    <TokenAndSpan as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TokenAndSpan as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
-                        self::fields::SimpleBlockField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ComponentValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeature {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeature::Plain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::Plain,
-                ));
-                <SizeFeaturePlain as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeaturePlain as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SizeFeature::Boolean { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::Boolean,
-                ));
-                <SizeFeatureBoolean as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeatureBoolean as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SizeFeature::Range { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::Range,
-                ));
-                <SizeFeatureRange as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeatureRange as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SizeFeature::RangeInterval { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::RangeInterval,
-                ));
-                <SizeFeatureRangeInterval as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SizeFeatureRangeInterval as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureBoolean {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_boolean`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_boolean(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureBoolean {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature_boolean`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature_boolean(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeatureBoolean { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
-                        self::fields::SizeFeatureBooleanField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
-                        self::fields::SizeFeatureBooleanField::Name,
-                    ));
-                    <SizeFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureName {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeatureName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureName(
-                    self::fields::SizeFeatureNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeaturePlain {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_plain`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_plain(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeaturePlain {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature_plain`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature_plain(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeaturePlain { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
-                        self::fields::SizeFeaturePlainField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
-                        self::fields::SizeFeaturePlainField::Name,
-                    ));
-                    <SizeFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
-                        self::fields::SizeFeaturePlainField::Value,
-                    ));
-                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRange {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_range`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRange {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature_range`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature_range(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeatureRange {
                 span,
@@ -70807,58 +49023,30 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRange {
                 right,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Left,
-                    ));
-                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Comparison,
-                    ));
-                    <SizeFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        comparison,
-                        visitor,
-                        &mut *__ast_path,
+                    <SizeFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
+                        comparison, visitor,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Right,
-                    ));
-                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRangeComparison {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_range_comparison`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRangeComparison {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature_range_comparison`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature_range_comparison(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeatureRangeComparison::Lt => {}
             SizeFeatureRangeComparison::Le => {}
@@ -70868,15 +49056,13 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRangeCom
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRangeInterval {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_range_interval`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureRangeInterval {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature_range_interval`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature_range_interval(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeatureRangeInterval {
                 span,
@@ -70887,340 +49073,156 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRangeInt
                 right,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Left,
-                        ));
-                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::LeftComparison,
-                        ));
-                    <SizeFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <SizeFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
                         left_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Name,
-                        ));
-                    <SizeFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
-                {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::RightComparison,
-                        ));
-                    <SizeFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                {
+                    <SizeFeatureRangeComparison as VisitMutWith<V>>::visit_mut_with(
                         right_comparison,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Right,
-                        ));
-                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SizeFeatureValue> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_size_feature_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SizeFeatureValue {
+    #[doc = "Calls [VisitMut`::visit_mut_size_feature_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_size_feature_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SizeFeatureValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Number,
-                ));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SizeFeatureValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Dimension,
-                ));
-                <Dimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Dimension as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SizeFeatureValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SizeFeatureValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Ratio,
-                ));
-                <Ratio as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ratio as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SizeFeatureValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Str {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_str`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_str(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Str {
+    #[doc = "Calls [VisitMut`::visit_mut_str`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_str(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Str { span, value, raw } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for StyleBlock {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_style_block`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_style_block(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for StyleBlock {
+    #[doc = "Calls [VisitMut`::visit_mut_style_block`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_style_block(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             StyleBlock::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::AtRule,
-                ));
-                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AtRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             StyleBlock::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::Declaration,
-                ));
-                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             StyleBlock::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::QualifiedRule,
-                ));
-                <Box<QualifiedRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<QualifiedRule> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             StyleBlock::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::ListOfComponentValues,
-                ));
-                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<ListOfComponentValues> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Stylesheet {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_stylesheet`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stylesheet(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Stylesheet {
+    #[doc = "Calls [VisitMut`::visit_mut_stylesheet`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_stylesheet(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Stylesheet { span, rules } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
-                        self::fields::StylesheetField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
-                        self::fields::StylesheetField::Rules(usize::MAX),
-                    ));
-                    <Vec<Rule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        rules,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Rule> as VisitMutWith<V>>::visit_mut_with(rules, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SubclassSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_subclass_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_subclass_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SubclassSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_subclass_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_subclass_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SubclassSelector::Id { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::Id,
-                ));
-                <IdSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SubclassSelector::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::Class,
-                ));
-                <ClassSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SubclassSelector::Attribute { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::Attribute,
-                ));
-                <Box<AttributeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<AttributeSelector> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SubclassSelector::PseudoClass { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::PseudoClass,
-                ));
-                <PseudoClassSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PseudoClassSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SubclassSelector::PseudoElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::PseudoElement,
-                ));
-                <PseudoElementSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PseudoElementSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsAnd {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_and`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_and(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsAnd {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_and`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_and(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SupportsAnd {
                 span,
@@ -71228,212 +49230,106 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsAnd {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
-                        self::fields::SupportsAndField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
-                        self::fields::SupportsAndField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
-                        self::fields::SupportsAndField::Condition,
-                    ));
-                    <Box<SupportsInParens> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SupportsInParens> as VisitMutWith<V>>::visit_mut_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsCondition {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_condition`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsCondition {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_condition`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_condition(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SupportsCondition { span, conditions } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
-                        self::fields::SupportsConditionField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
-                        self::fields::SupportsConditionField::Conditions(usize::MAX),
-                    ));
-                    <Vec<SupportsConditionType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
+                    <Vec<SupportsConditionType> as VisitMutWith<V>>::visit_mut_with(
+                        conditions, visitor,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsConditionType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_condition_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsConditionType {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_condition_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_condition_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SupportsConditionType::Not { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::Not,
-                ));
-                <SupportsNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsNot as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SupportsConditionType::And { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::And,
-                ));
-                <SupportsAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsAnd as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SupportsConditionType::Or { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::Or,
-                ));
-                <SupportsOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsOr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SupportsConditionType::SupportsInParens { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::SupportsInParens,
-                ));
-                <SupportsInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsInParens as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsFeature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_feature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_feature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsFeature {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_feature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_feature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SupportsFeature::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
-                    self::fields::SupportsFeatureField::Declaration,
-                ));
-                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Declaration> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SupportsFeature::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
-                    self::fields::SupportsFeatureField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsInParens {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_in_parens`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsInParens {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_in_parens`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_in_parens(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SupportsInParens::SupportsCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
-                    self::fields::SupportsInParensField::SupportsCondition,
-                ));
-                <SupportsCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsCondition as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SupportsInParens::Feature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
-                    self::fields::SupportsInParensField::Feature,
-                ));
-                <SupportsFeature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SupportsFeature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SupportsInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
-                    self::fields::SupportsInParensField::GeneralEnclosed,
-                ));
-                <GeneralEnclosed as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GeneralEnclosed as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsNot {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_not`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_not(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsNot {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_not`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_not(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SupportsNot {
                 span,
@@ -71441,48 +49337,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsNot {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
-                        self::fields::SupportsNotField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
-                        self::fields::SupportsNotField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
-                        self::fields::SupportsNotField::Condition,
-                    ));
-                    <Box<SupportsInParens> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SupportsInParens> as VisitMutWith<V>>::visit_mut_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsOr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_or`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_or(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SupportsOr {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_or`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_or(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SupportsOr {
                 span,
@@ -71490,380 +49363,166 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsOr {
                 condition,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
-                        self::fields::SupportsOrField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
-                        self::fields::SupportsOrField::Keyword,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(keyword, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
-                        self::fields::SupportsOrField::Condition,
-                    ));
-                    <Box<SupportsInParens> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<SupportsInParens> as VisitMutWith<V>>::visit_mut_with(condition, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TagNameSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_tag_name_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tag_name_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TagNameSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_tag_name_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_tag_name_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TagNameSelector { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
-                        self::fields::TagNameSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
-                        self::fields::TagNameSelectorField::Name,
-                    ));
-                    <WqName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <WqName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Time {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_time`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_time(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Time {
+    #[doc = "Calls [VisitMut`::visit_mut_time`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_time(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Time { span, value, unit } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Value));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Unit));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TimePercentage {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_time_percentage`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_time_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TimePercentage {
+    #[doc = "Calls [VisitMut`::visit_mut_time_percentage`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_time_percentage(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TimePercentage::Time { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
-                    self::fields::TimePercentageField::Time,
-                ));
-                <Time as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Time as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TimePercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
-                    self::fields::TimePercentageField::Percentage,
-                ));
-                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Percentage as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Token {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_token`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_token(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Token {
+    #[doc = "Calls [VisitMut`::visit_mut_token`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_token(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Token::Ident { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Ident));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::Function { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Function));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::AtKeyword { value, raw } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::AtKeyword));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::Hash { is_id, value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Hash));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::String { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::String));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::BadString { raw } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::BadString));
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::Url { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Url));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <Box<UrlKeyValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<UrlKeyValue> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::BadUrl { raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::BadUrl));
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
-            Token::Delim { value } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Delim));
-            }
+            Token::Delim { value } => {}
             Token::Number {
                 value,
                 raw,
                 type_flag,
             } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Number));
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::TypeFlag));
-                    <NumberType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_flag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <NumberType as VisitMutWith<V>>::visit_mut_with(type_flag, visitor)
                 };
             }
             Token::Percentage { value, raw } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::Percentage));
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
             Token::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::Dimension));
-                <Box<DimensionToken> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<DimensionToken> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Token::WhiteSpace { value } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::WhiteSpace));
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
             Token::CDO => {}
@@ -71880,83 +49539,49 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Token {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TokenAndSpan {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_token_and_span`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_token_and_span(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TokenAndSpan {
+    #[doc = "Calls [VisitMut`::visit_mut_token_and_span`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_token_and_span(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TokenAndSpan { span, token } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
-                        self::fields::TokenAndSpanField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
-                        self::fields::TokenAndSpanField::Token,
-                    ));
-                    <Token as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Token as VisitMutWith<V>>::visit_mut_with(token, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TypeSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_type_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_type_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TypeSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_type_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_type_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TypeSelector::TagName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
-                    self::fields::TypeSelectorField::TagName,
-                ));
-                <TagNameSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TagNameSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TypeSelector::Universal { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
-                    self::fields::TypeSelectorField::Universal,
-                ));
-                <UniversalSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UniversalSelector as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnicodeRange {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_unicode_range`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unicode_range(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnicodeRange {
+    #[doc = "Calls [VisitMut`::visit_mut_unicode_range`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_unicode_range(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UnicodeRange {
                 span,
@@ -71965,138 +49590,69 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnicodeRange {
                 raw,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::Start,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        start,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(start, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::End,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        end,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(end, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UniversalSelector {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_universal_selector`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_universal_selector(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UniversalSelector {
+    #[doc = "Calls [VisitMut`::visit_mut_universal_selector`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_universal_selector(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UniversalSelector { span, prefix } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
-                        self::fields::UniversalSelectorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
-                        self::fields::UniversalSelectorField::Prefix,
-                    ));
-                    <Option<NamespacePrefix> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<NamespacePrefix> as VisitMutWith<V>>::visit_mut_with(prefix, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnknownDimension {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_unknown_dimension`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unknown_dimension(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnknownDimension {
+    #[doc = "Calls [VisitMut`::visit_mut_unknown_dimension`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_unknown_dimension(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UnknownDimension { span, value, unit } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
-                        self::fields::UnknownDimensionField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
-                        self::fields::UnknownDimensionField::Value,
-                    ));
-                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Number as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
-                        self::fields::UnknownDimensionField::Unit,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(unit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Url {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_url`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Url {
+    #[doc = "Calls [VisitMut`::visit_mut_url`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_url(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Url {
                 span,
@@ -72105,192 +49661,104 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Url {
                 modifiers,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Name));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Value));
-                    <Option<Box<UrlValue>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<UrlValue>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Url(
-                        self::fields::UrlField::Modifiers(usize::MAX),
-                    ));
-                    <Option<Vec<UrlModifier>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        modifiers,
-                        visitor,
-                        &mut *__ast_path,
+                    <Option<Vec<UrlModifier>> as VisitMutWith<V>>::visit_mut_with(
+                        modifiers, visitor,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlKeyValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_key_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_key_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlKeyValue {
+    #[doc = "Calls [VisitMut`::visit_mut_url_key_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_url_key_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UrlKeyValue {
                 0: _field_0,
                 1: _field_1,
             } => {
-                <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_1,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(_field_1, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlModifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_modifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_modifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlModifier {
+    #[doc = "Calls [VisitMut`::visit_mut_url_modifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_url_modifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UrlModifier::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
-                    self::fields::UrlModifierField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             UrlModifier::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
-                    self::fields::UrlModifierField::Function,
-                ));
-                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Function as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlValue {
+    #[doc = "Calls [VisitMut`::visit_mut_url_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_url_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UrlValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Str));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             UrlValue::Raw { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Raw));
-                <UrlValueRaw as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UrlValueRaw as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlValueRaw {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_value_raw`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_value_raw(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UrlValueRaw {
+    #[doc = "Calls [VisitMut`::visit_mut_url_value_raw`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_url_value_raw(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UrlValueRaw { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
-                        self::fields::UrlValueRawField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
-                        self::fields::UrlValueRawField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
-                        self::fields::UrlValueRawField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WqName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_wq_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_wq_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for WqName {
+    #[doc = "Calls [VisitMut`::visit_mut_wq_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_wq_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             WqName {
                 span,
@@ -72298,10125 +49766,13461 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WqName {
                 value,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Prefix));
-                    <Option<NamespacePrefix> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<NamespacePrefix> as VisitMutWith<V>>::visit_mut_with(prefix, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Value));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_atoms::Atom {
+    #[doc = "Calls [VisitMut`::visit_mut_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_atom(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CalcProductOrOperator> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_product_or_operators`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CalcProductOrOperator> {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_product_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_product_or_operators(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CalcProductOrOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <CalcProductOrOperator as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CalcValueOrOperator> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_value_or_operators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CalcValueOrOperator> {
+    #[doc = "Calls [VisitMut`::visit_mut_calc_value_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_calc_value_or_operators(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CalcValueOrOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <CalcValueOrOperator as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComplexSelectorChildren> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selector_childrens`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComplexSelectorChildren> {
+    #[doc = "Calls [VisitMut`::visit_mut_complex_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_complex_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ComplexSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <ComplexSelectorChildren as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComplexSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComplexSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_complex_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_complex_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ComplexSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComponentValue> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_component_values`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComponentValue> {
+    #[doc = "Calls [VisitMut`::visit_mut_component_values`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_component_values(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_component_values(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ComponentValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ComponentValue as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CompoundSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_compound_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CompoundSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_compound_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_compound_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_compound_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <CompoundSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ContainerQueryType> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ContainerQueryType> {
+    #[doc = "Calls [VisitMut`::visit_mut_container_query_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_container_query_types(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_container_query_types(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ContainerQueryType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ContainerQueryType as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CustomIdent> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_idents`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CustomIdent> {
+    #[doc = "Calls [VisitMut`::visit_mut_custom_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_custom_idents(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_custom_idents(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <CustomIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <CustomIdent as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<DocumentPreludeMatchingFunction> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_document_prelude_matching_functions`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<DocumentPreludeMatchingFunction> {
+    #[doc = "Calls [VisitMut`::visit_mut_document_prelude_matching_functions`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
-            visitor, self, __ast_path,
-        )
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_document_prelude_matching_functions(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <DocumentPreludeMatchingFunction as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <DocumentPreludeMatchingFunction as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<FamilyName> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_family_names`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<FamilyName> {
+    #[doc = "Calls [VisitMut`::visit_mut_family_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_family_names(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_family_names(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <FamilyName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <FamilyName as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingComplexSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_complex_selectors`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ForgivingComplexSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_forgiving_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_forgiving_complex_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ForgivingComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <ForgivingComplexSelector as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingRelativeSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_relative_selectors`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ForgivingRelativeSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_forgiving_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_forgiving_relative_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ForgivingRelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <ForgivingRelativeSelector as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Ident> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_idents`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Ident> {
+    #[doc = "Calls [VisitMut`::visit_mut_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_idents(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_idents(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Ident as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<KeyframeSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframe_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<KeyframeSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_keyframe_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_keyframe_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_keyframe_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <KeyframeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <KeyframeSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<LayerName> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_names`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<LayerName> {
+    #[doc = "Calls [VisitMut`::visit_mut_layer_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_layer_names(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_layer_names(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <LayerName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <LayerName as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaConditionAllType> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_all_types`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaConditionAllType> {
+    #[doc = "Calls [VisitMut`::visit_mut_media_condition_all_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_all_types(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_condition_all_types(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <MediaConditionAllType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <MediaConditionAllType as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaConditionWithoutOrType> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_without_or_types`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaConditionWithoutOrType> {
+    #[doc = "Calls [VisitMut`::visit_mut_media_condition_without_or_types`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
-            visitor, self, __ast_path,
-        )
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_condition_without_or_types(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <MediaConditionWithoutOrType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <MediaConditionWithoutOrType as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaQuery> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_querys`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaQuery> {
+    #[doc = "Calls [VisitMut`::visit_mut_media_querys`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_media_querys(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_media_querys(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <MediaQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <MediaQuery as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<AtRulePrelude>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_at_rule_prelude`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<AtRulePrelude>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_at_rule_prelude`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_at_rule_prelude(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<AtRulePrelude> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<AtRulePrelude> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_atom(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorMatcher> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_attribute_selector_matcher`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorMatcher> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <AttributeSelectorMatcher as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <AttributeSelectorMatcher as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorModifier> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_attribute_selector_modifier`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorModifier> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_attribute_selector_modifier`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <AttributeSelectorModifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <AttributeSelectorModifier as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorValue> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_attribute_selector_value`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorValue> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_attribute_selector_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_attribute_selector_value(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <AttributeSelectorValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <AttributeSelectorValue as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Combinator> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_combinator`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Combinator> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_combinator`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_combinator(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_combinator(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Combinator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Combinator as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ContainerName> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_container_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ContainerName> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_container_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_container_name(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_container_name(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <ContainerName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ContainerName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ForgivingSelectorList> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_forgiving_selector_list`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ForgivingSelectorList> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_forgiving_selector_list(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <ForgivingSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <ForgivingSelectorList as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Function>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_function`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Function>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_function`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_function(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_function(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<Function> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Ident> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Ident> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ident(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ident(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Ident as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ImportConditions>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_import_conditions`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ImportConditions>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_import_conditions`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_import_conditions(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_import_conditions(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Box<ImportConditions> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <Box<ImportConditions> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ImportLayerName>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_import_layer_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ImportLayerName>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_import_layer_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_import_layer_name(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Box<ImportLayerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <Box<ImportLayerName> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ImportantFlag> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_important_flag`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ImportantFlag> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_important_flag`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_important_flag(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_important_flag(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <ImportantFlag as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ImportantFlag as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<MediaConditionType>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_media_condition_type`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<MediaConditionType>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_media_condition_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_media_condition_type(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Box<MediaConditionType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <Box<MediaConditionType> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<MediaQueryList>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_media_query_list`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<MediaQueryList>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_media_query_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_query_list(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_media_query_list(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Box<MediaQueryList> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
-            }
+            Some(inner) => <Box<MediaQueryList> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<MediaType> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_media_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<MediaType> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_media_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_media_type(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_media_type(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <MediaType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <MediaType as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Namespace> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_namespace`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Namespace> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_namespace`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_namespace(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_namespace(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Namespace as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Namespace as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<NamespacePrefix> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_namespace_prefix`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<NamespacePrefix> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_namespace_prefix`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_namespace_prefix(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <NamespacePrefix as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <NamespacePrefix as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<NestingSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_nesting_selector`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<NestingSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_nesting_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_nesting_selector(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <NestingSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <NestingSelector as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Number> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_number`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Number> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_number`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_number(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_number(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Number as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<PageSelectorPseudo>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_page_selector_pseudos`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PageSelectorPseudo>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_page_selector_pseudos(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Vec<PageSelectorPseudo> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <Vec<PageSelectorPseudo> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<PageSelectorType> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_page_selector_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<PageSelectorType> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_page_selector_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_page_selector_type(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <PageSelectorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <PageSelectorType as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V>
-    for Option<Vec<PseudoClassSelectorChildren>>
-{
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_pseudo_class_selector_childrens`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
-            visitor, self, __ast_path,
-        )
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        match self { Some (inner) => { < Vec < PseudoClassSelectorChildren > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (inner , visitor , __ast_path) } None => { } }
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        match self {
+            Some(inner) => <Vec<PseudoClassSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
+                inner, visitor,
+            ),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V>
-    for Option<Vec<PseudoElementSelectorChildren>>
-{
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_pseudo_element_selector_childrens`] with \
-             `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_pseudo_element_selector_childrens`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
-            visitor, self, __ast_path,
-        )
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        match self { Some (inner) => { < Vec < PseudoElementSelectorChildren > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (inner , visitor , __ast_path) } None => { } }
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        match self {
+            Some(inner) => <Vec<PseudoElementSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
+                inner, visitor,
+            ),
+            None => {}
+        }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<SimpleBlock> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_simple_block`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<SimpleBlock> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_simple_block`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_simple_block(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_simple_block(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <SimpleBlock as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TypeSelector>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_type_selector`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TypeSelector>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_type_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_type_selector(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_type_selector(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<TypeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<TypeSelector> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<UrlModifier>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_url_modifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<UrlModifier>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_url_modifiers(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Vec<UrlModifier> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Vec<UrlModifier> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<UrlValue>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_url_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<UrlValue>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_url_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_url_value(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_url_value(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<UrlValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<UrlValue> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PageSelectorPseudo> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_pseudos`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PageSelectorPseudo> {
+    #[doc = "Calls [VisitMut`::visit_mut_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_page_selector_pseudos(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PageSelectorPseudo as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <PageSelectorPseudo as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PageSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PageSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_page_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_page_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_page_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PageSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <PageSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoClassSelectorChildren> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_class_selector_childrens`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PseudoClassSelectorChildren> {
+    #[doc = "Calls [VisitMut`::visit_mut_pseudo_class_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PseudoClassSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <PseudoClassSelectorChildren as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoElementSelectorChildren> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_element_selector_childrens`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PseudoElementSelectorChildren> {
+    #[doc = "Calls [VisitMut`::visit_mut_pseudo_element_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
-            visitor, self, __ast_path,
-        )
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PseudoElementSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <PseudoElementSelectorChildren as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<RelativeSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_relative_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<RelativeSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_relative_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_relative_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <RelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <RelativeSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Rule> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_rules`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Rule> {
+    #[doc = "Calls [VisitMut`::visit_mut_rules`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rules(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_rules(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Rule as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Rule as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::Span {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_span`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_common::Span {
+    #[doc = "Calls [VisitMut`::visit_mut_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_span(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_span(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SubclassSelector> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_subclass_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SubclassSelector> {
+    #[doc = "Calls [VisitMut`::visit_mut_subclass_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_subclass_selectors(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_subclass_selectors(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <SubclassSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <SubclassSelector as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SupportsConditionType> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_condition_types`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SupportsConditionType> {
+    #[doc = "Calls [VisitMut`::visit_mut_supports_condition_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_supports_condition_types(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_supports_condition_types(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <SupportsConditionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <SupportsConditionType as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<UrlModifier> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_modifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<UrlModifier> {
+    #[doc = "Calls [VisitMut`::visit_mut_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_url_modifiers(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_url_modifiers(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <UrlModifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <UrlModifier as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> VisitMutWithAstPath<V> for std::boxed::Box<T>
+impl<V, T> VisitMutWith<V> for std::boxed::Box<T>
 where
-    V: ?Sized + VisitMutAstPath,
-    T: VisitMutWithAstPath<V>,
+    V: ?Sized + VisitMut,
+    T: VisitMutWith<V>,
 {
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        let v = <T as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-            &mut **self,
-            visitor,
-            __ast_path,
-        );
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        let v = <T as VisitMutWith<V>>::visit_mut_with(&mut **self, visitor);
         v
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        let v = <T as VisitMutWithAstPath<V>>::visit_mut_children_with_ast_path(
-            &mut **self,
-            visitor,
-            __ast_path,
-        );
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
         v
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-pub trait Fold {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
-             [`AbsoluteColorBase::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AbsoluteColorBase::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
-        <AbsoluteColorBase as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_absolute_color_base(
+        &mut self,
+        node: &mut AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AbsoluteColorBase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
-             [`AlphaValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AlphaValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
-        <AlphaValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
+        <AlphaValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
-             [`AnPlusB::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`AnPlusB::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
-        <AnPlusB as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
+        <AnPlusB as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
-             [`AnPlusBNotation::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AnPlusBNotation::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
-        <AnPlusBNotation as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_an_plus_b_notation(
+        &mut self,
+        node: &mut AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AnPlusBNotation as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
-             [`Angle::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Angle::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_angle(&mut self, node: Angle) -> Angle {
-        <Angle as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
+        <Angle as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
-             [`AnglePercentage::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AnglePercentage::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
-        <AnglePercentage as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_angle_percentage(
+        &mut self,
+        node: &mut AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AnglePercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
-             [`AnyNamespace::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AnyNamespace::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
-        <AnyNamespace as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
+        <AnyNamespace as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
-             [`AtRule::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`AtRule::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
-        <AtRule as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
+        <AtRule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
-             [`AtRuleName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AtRuleName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
-        <AtRuleName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
+        <AtRuleName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
-             [`AtRulePrelude::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AtRulePrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
-        <AtRulePrelude as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_at_rule_prelude(
+        &mut self,
+        node: &mut AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AtRulePrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`swc_atoms :: Atom::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
-        <swc_atoms::Atom as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+        <swc_atoms::Atom as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
-             [`AttributeSelector::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AttributeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
-        <AttributeSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_attribute_selector(
+        &mut self,
+        node: &mut AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AttributeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
-             [`AttributeSelectorMatcher::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AttributeSelectorMatcher::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_attribute_selector_matcher(
+    fn visit_mut_attribute_selector_matcher(
         &mut self,
-        node: AttributeSelectorMatcher,
-    ) -> AttributeSelectorMatcher {
-        <AttributeSelectorMatcher as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AttributeSelectorMatcher as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
-             calls [`AttributeSelectorMatcherValue::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`AttributeSelectorMatcherValue::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_attribute_selector_matcher_value(
+    fn visit_mut_attribute_selector_matcher_value(
         &mut self,
-        node: AttributeSelectorMatcherValue,
-    ) -> AttributeSelectorMatcherValue {
-        <AttributeSelectorMatcherValue as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < AttributeSelectorMatcherValue as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
-             [`AttributeSelectorModifier::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AttributeSelectorModifier::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_attribute_selector_modifier(
+    fn visit_mut_attribute_selector_modifier(
         &mut self,
-        node: AttributeSelectorModifier,
-    ) -> AttributeSelectorModifier {
-        <AttributeSelectorModifier as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AttributeSelectorModifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
-             [`AttributeSelectorValue::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AttributeSelectorValue::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_attribute_selector_value(
+    fn visit_mut_attribute_selector_value(
         &mut self,
-        node: AttributeSelectorValue,
-    ) -> AttributeSelectorValue {
-        <AttributeSelectorValue as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AttributeSelectorValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
-             [`BinOp::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`BinOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
-        <BinOp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
+        <BinOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
-             [`CalcOperator::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CalcOperator::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
-        <CalcOperator as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
+        <CalcOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
-             [`CalcOperatorType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CalcOperatorType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
-        <CalcOperatorType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_calc_operator_type(
+        &mut self,
+        node: &mut CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CalcOperatorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
-             [`CalcProduct::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CalcProduct::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
-        <CalcProduct as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
+        <CalcProduct as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
-             [`CalcProductOrOperator::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CalcProductOrOperator::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_calc_product_or_operator(
+    fn visit_mut_calc_product_or_operator(
         &mut self,
-        node: CalcProductOrOperator,
-    ) -> CalcProductOrOperator {
-        <CalcProductOrOperator as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CalcProductOrOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
-             calls [`Vec < CalcProductOrOperator >::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`Vec < CalcProductOrOperator >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_calc_product_or_operators(
+    fn visit_mut_calc_product_or_operators(
         &mut self,
-        node: Vec<CalcProductOrOperator>,
-    ) -> Vec<CalcProductOrOperator> {
-        <Vec<CalcProductOrOperator> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<CalcProductOrOperator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
-             [`CalcSum::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`CalcSum::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
-        <CalcSum as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
+        <CalcSum as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
-             [`CalcValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CalcValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
-        <CalcValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
+        <CalcValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
-             [`CalcValueOrOperator::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`CalcValueOrOperator::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
-        <CalcValueOrOperator as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_calc_value_or_operator(
+        &mut self,
+        node: &mut CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CalcValueOrOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
-             [`Vec < CalcValueOrOperator >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Vec < CalcValueOrOperator >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_calc_value_or_operators(
+    fn visit_mut_calc_value_or_operators(
         &mut self,
-        node: Vec<CalcValueOrOperator>,
-    ) -> Vec<CalcValueOrOperator> {
-        <Vec<CalcValueOrOperator> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<CalcValueOrOperator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
-             [`ClassSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
-        <ClassSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
+        <ClassSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
-             [`CmykComponent::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CmykComponent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
-        <CmykComponent as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
+        <CmykComponent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
-             [`Color::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Color::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_color(&mut self, node: Color) -> Color {
-        <Color as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
+        <Color as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
-             [`ColorProfileName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ColorProfileName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
-        <ColorProfileName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_color_profile_name(
+        &mut self,
+        node: &mut ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ColorProfileName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
-             [`Combinator::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Combinator::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
-        <Combinator as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
+        <Combinator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
-             [`CombinatorValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CombinatorValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
-        <CombinatorValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_combinator_value(
+        &mut self,
+        node: &mut CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CombinatorValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
-             [`ComplexSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ComplexSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
-        <ComplexSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_complex_selector(
+        &mut self,
+        node: &mut ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ComplexSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
-             [`ComplexSelectorChildren::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ComplexSelectorChildren::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_complex_selector_children(
+    fn visit_mut_complex_selector_children(
         &mut self,
-        node: ComplexSelectorChildren,
-    ) -> ComplexSelectorChildren {
-        <ComplexSelectorChildren as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ComplexSelectorChildren as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
-             calls [`Vec < ComplexSelectorChildren >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < ComplexSelectorChildren >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_complex_selector_childrens(
+    fn visit_mut_complex_selector_childrens(
         &mut self,
-        node: Vec<ComplexSelectorChildren>,
-    ) -> Vec<ComplexSelectorChildren> {
-        <Vec<ComplexSelectorChildren> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Vec < ComplexSelectorChildren > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
-             [`Vec < ComplexSelector >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < ComplexSelector >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
-        <Vec<ComplexSelector> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_complex_selectors(
+        &mut self,
+        node: &mut Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ComplexSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
-             [`ComponentValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ComponentValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
-        <ComponentValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_component_value(
+        &mut self,
+        node: &mut ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ComponentValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
-             < ComponentValue >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < ComponentValue >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
-        <Vec<ComponentValue> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_component_values(
+        &mut self,
+        node: &mut Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ComponentValue> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
-             [`CompoundSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CompoundSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
-        <CompoundSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_compound_selector(
+        &mut self,
+        node: &mut CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CompoundSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
-             [`CompoundSelectorList::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CompoundSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
-        <CompoundSelectorList as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_compound_selector_list(
+        &mut self,
+        node: &mut CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CompoundSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
-             [`Vec < CompoundSelector >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < CompoundSelector >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
-        <Vec<CompoundSelector> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_compound_selectors(
+        &mut self,
+        node: &mut Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<CompoundSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
-             [`ContainerCondition::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ContainerCondition::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
-        <ContainerCondition as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_container_condition(
+        &mut self,
+        node: &mut ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ContainerCondition as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
-             [`ContainerName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ContainerName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
-        <ContainerName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
+        <ContainerName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
-             [`ContainerQuery::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ContainerQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
-        <ContainerQuery as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_container_query(
+        &mut self,
+        node: &mut ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ContainerQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
-             [`ContainerQueryAnd::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ContainerQueryAnd::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
-        <ContainerQueryAnd as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_container_query_and(
+        &mut self,
+        node: &mut ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ContainerQueryAnd as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
-             [`ContainerQueryNot::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ContainerQueryNot::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
-        <ContainerQueryNot as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_container_query_not(
+        &mut self,
+        node: &mut ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ContainerQueryNot as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
-             [`ContainerQueryOr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ContainerQueryOr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
-        <ContainerQueryOr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_container_query_or(
+        &mut self,
+        node: &mut ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ContainerQueryOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
-             [`ContainerQueryType::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ContainerQueryType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
-        <ContainerQueryType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_container_query_type(
+        &mut self,
+        node: &mut ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ContainerQueryType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
-             [`Vec < ContainerQueryType >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Vec < ContainerQueryType >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_container_query_types(
+    fn visit_mut_container_query_types(
         &mut self,
-        node: Vec<ContainerQueryType>,
-    ) -> Vec<ContainerQueryType> {
-        <Vec<ContainerQueryType> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ContainerQueryType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
-             [`CustomHighlightName::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`CustomHighlightName::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
-        <CustomHighlightName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_custom_highlight_name(
+        &mut self,
+        node: &mut CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CustomHighlightName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
-             [`CustomIdent::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CustomIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
-        <CustomIdent as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
+        <CustomIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
-             CustomIdent >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             CustomIdent >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
-        <Vec<CustomIdent> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_custom_idents(
+        &mut self,
+        node: &mut Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<CustomIdent> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
-             [`CustomMediaQuery::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CustomMediaQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
-        <CustomMediaQuery as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_custom_media_query(
+        &mut self,
+        node: &mut CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CustomMediaQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
-             [`CustomMediaQueryMediaType::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CustomMediaQueryMediaType::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_custom_media_query_media_type(
+    fn visit_mut_custom_media_query_media_type(
         &mut self,
-        node: CustomMediaQueryMediaType,
-    ) -> CustomMediaQueryMediaType {
-        <CustomMediaQueryMediaType as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CustomMediaQueryMediaType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
-             [`CustomPropertyName::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`CustomPropertyName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
-        <CustomPropertyName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_custom_property_name(
+        &mut self,
+        node: &mut CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <CustomPropertyName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
-             [`DashedIdent::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DashedIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
-        <DashedIdent as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
+        <DashedIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
-             [`Declaration::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Declaration::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
-        <Declaration as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
+        <Declaration as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
-             [`DeclarationName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DeclarationName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
-        <DeclarationName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_declaration_name(
+        &mut self,
+        node: &mut DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <DeclarationName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
-             [`DeclarationOrAtRule::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`DeclarationOrAtRule::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
-        <DeclarationOrAtRule as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_declaration_or_at_rule(
+        &mut self,
+        node: &mut DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <DeclarationOrAtRule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
-             [`Delimiter::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Delimiter::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
-        <Delimiter as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
+        <Delimiter as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
-             [`DelimiterValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DelimiterValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
-        <DelimiterValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_delimiter_value(
+        &mut self,
+        node: &mut DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <DelimiterValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
-             [`Dimension::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Dimension::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
-        <Dimension as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
+        <Dimension as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
-             [`DimensionToken::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DimensionToken::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
-        <DimensionToken as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_dimension_token(
+        &mut self,
+        node: &mut DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <DimensionToken as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
-             [`DocumentPrelude::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DocumentPrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
-        <DocumentPrelude as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_document_prelude(
+        &mut self,
+        node: &mut DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <DocumentPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
-             calls [`DocumentPreludeMatchingFunction::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`DocumentPreludeMatchingFunction::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_document_prelude_matching_function(
+    fn visit_mut_document_prelude_matching_function(
         &mut self,
-        node: DocumentPreludeMatchingFunction,
-    ) -> DocumentPreludeMatchingFunction {
-        <DocumentPreludeMatchingFunction as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < DocumentPreludeMatchingFunction as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
-             method calls [`Vec < DocumentPreludeMatchingFunction >::fold_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+             method calls [`Vec < DocumentPreludeMatchingFunction \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_document_prelude_matching_functions(
+    fn visit_mut_document_prelude_matching_functions(
         &mut self,
-        node: Vec<DocumentPreludeMatchingFunction>,
-    ) -> Vec<DocumentPreludeMatchingFunction> {
-        <Vec<DocumentPreludeMatchingFunction> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Vec < DocumentPreludeMatchingFunction > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
-             [`ExtensionName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExtensionName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
-        <ExtensionName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
+        <ExtensionName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
-             [`FamilyName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`FamilyName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
-        <FamilyName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
+        <FamilyName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
-             FamilyName >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             FamilyName >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
-        <Vec<FamilyName> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
+        <Vec<FamilyName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
-             [`Flex::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Flex::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_flex(&mut self, node: Flex) -> Flex {
-        <Flex as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
+        <Flex as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
-             [`FontFeatureValuesPrelude::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`FontFeatureValuesPrelude::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_font_feature_values_prelude(
+    fn visit_mut_font_feature_values_prelude(
         &mut self,
-        node: FontFeatureValuesPrelude,
-    ) -> FontFeatureValuesPrelude {
-        <FontFeatureValuesPrelude as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <FontFeatureValuesPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
-             [`ForgivingComplexSelector::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ForgivingComplexSelector::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_forgiving_complex_selector(
+    fn visit_mut_forgiving_complex_selector(
         &mut self,
-        node: ForgivingComplexSelector,
-    ) -> ForgivingComplexSelector {
-        <ForgivingComplexSelector as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ForgivingComplexSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingComplexSelector >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < ForgivingComplexSelector >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_forgiving_complex_selectors(
+    fn visit_mut_forgiving_complex_selectors(
         &mut self,
-        node: Vec<ForgivingComplexSelector>,
-    ) -> Vec<ForgivingComplexSelector> {
-        <Vec<ForgivingComplexSelector> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Vec < ForgivingComplexSelector > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
-             [`ForgivingRelativeSelector::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ForgivingRelativeSelector::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_forgiving_relative_selector(
+    fn visit_mut_forgiving_relative_selector(
         &mut self,
-        node: ForgivingRelativeSelector,
-    ) -> ForgivingRelativeSelector {
-        <ForgivingRelativeSelector as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ForgivingRelativeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
-             calls [`ForgivingRelativeSelectorList::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`ForgivingRelativeSelectorList::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_forgiving_relative_selector_list(
+    fn visit_mut_forgiving_relative_selector_list(
         &mut self,
-        node: ForgivingRelativeSelectorList,
-    ) -> ForgivingRelativeSelectorList {
-        <ForgivingRelativeSelectorList as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < ForgivingRelativeSelectorList as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingRelativeSelector >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < ForgivingRelativeSelector >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_forgiving_relative_selectors(
+    fn visit_mut_forgiving_relative_selectors(
         &mut self,
-        node: Vec<ForgivingRelativeSelector>,
-    ) -> Vec<ForgivingRelativeSelector> {
-        <Vec<ForgivingRelativeSelector> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Vec < ForgivingRelativeSelector > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
-             [`ForgivingSelectorList::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ForgivingSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_forgiving_selector_list(
+    fn visit_mut_forgiving_selector_list(
         &mut self,
-        node: ForgivingSelectorList,
-    ) -> ForgivingSelectorList {
-        <ForgivingSelectorList as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ForgivingSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
-             [`Frequency::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Frequency::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
-        <Frequency as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
+        <Frequency as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
-             [`FrequencyPercentage::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`FrequencyPercentage::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
-        <FrequencyPercentage as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_frequency_percentage(
+        &mut self,
+        node: &mut FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <FrequencyPercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Function::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
-        <Function as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+        <Function as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
-             [`FunctionName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`FunctionName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
-        <FunctionName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
+        <FunctionName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
-             [`GeneralEnclosed::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`GeneralEnclosed::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
-        <GeneralEnclosed as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_general_enclosed(
+        &mut self,
+        node: &mut GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <GeneralEnclosed as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
-             [`HexColor::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`HexColor::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
-        <HexColor as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
+        <HexColor as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
-             [`Hue::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Hue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_hue(&mut self, node: Hue) -> Hue {
-        <Hue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
+        <Hue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
-             [`IdSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`IdSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
-        <IdSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
+        <IdSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Ident::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
-        <Ident as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+        <Ident as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
-        <Vec<Ident> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
+        <Vec<Ident> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
-             [`ImportConditions::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportConditions::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
-        <ImportConditions as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_conditions(
+        &mut self,
+        node: &mut ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ImportConditions as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
-             [`ImportHref::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportHref::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
-        <ImportHref as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
+        <ImportHref as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
-             [`ImportLayerName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportLayerName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
-        <ImportLayerName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_layer_name(
+        &mut self,
+        node: &mut ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ImportLayerName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
-             [`ImportPrelude::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportPrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
-        <ImportPrelude as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
+        <ImportPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
-             [`ImportantFlag::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportantFlag::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
-        <ImportantFlag as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
+        <ImportantFlag as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
-             [`Integer::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Integer::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_integer(&mut self, node: Integer) -> Integer {
-        <Integer as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
+        <Integer as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
-             [`KeyframeBlock::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`KeyframeBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
-        <KeyframeBlock as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
+        <KeyframeBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
-             [`KeyframeSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`KeyframeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
-        <KeyframeSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_keyframe_selector(
+        &mut self,
+        node: &mut KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <KeyframeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
-             [`Vec < KeyframeSelector >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < KeyframeSelector >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
-        <Vec<KeyframeSelector> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_keyframe_selectors(
+        &mut self,
+        node: &mut Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<KeyframeSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
-             [`KeyframesName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`KeyframesName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
-        <KeyframesName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
+        <KeyframesName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
-             [`KeyframesPseudoFunction::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`KeyframesPseudoFunction::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_keyframes_pseudo_function(
+    fn visit_mut_keyframes_pseudo_function(
         &mut self,
-        node: KeyframesPseudoFunction,
-    ) -> KeyframesPseudoFunction {
-        <KeyframesPseudoFunction as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <KeyframesPseudoFunction as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
-             [`KeyframesPseudoPrefix::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`KeyframesPseudoPrefix::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_keyframes_pseudo_prefix(
+    fn visit_mut_keyframes_pseudo_prefix(
         &mut self,
-        node: KeyframesPseudoPrefix,
-    ) -> KeyframesPseudoPrefix {
-        <KeyframesPseudoPrefix as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <KeyframesPseudoPrefix as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
-             [`LayerName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`LayerName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
-        <LayerName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
+        <LayerName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
-             [`LayerNameList::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`LayerNameList::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
-        <LayerNameList as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_layer_name_list(
+        &mut self,
+        node: &mut LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <LayerNameList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
-             LayerName >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             LayerName >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
-        <Vec<LayerName> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
+        <Vec<LayerName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
-             [`LayerPrelude::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`LayerPrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
-        <LayerPrelude as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
+        <LayerPrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
-             [`Length::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Length::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_length(&mut self, node: Length) -> Length {
-        <Length as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
+        <Length as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
-             [`LengthPercentage::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`LengthPercentage::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
-        <LengthPercentage as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_length_percentage(
+        &mut self,
+        node: &mut LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <LengthPercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
-             [`ListOfComponentValues::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ListOfComponentValues::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_list_of_component_values(
+    fn visit_mut_list_of_component_values(
         &mut self,
-        node: ListOfComponentValues,
-    ) -> ListOfComponentValues {
-        <ListOfComponentValues as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ListOfComponentValues as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
-             [`MediaAnd::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaAnd::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
-        <MediaAnd as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
+        <MediaAnd as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
-             [`MediaCondition::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaCondition::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
-        <MediaCondition as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_condition(
+        &mut self,
+        node: &mut MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaCondition as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
-             [`MediaConditionAllType::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaConditionAllType::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_media_condition_all_type(
+    fn visit_mut_media_condition_all_type(
         &mut self,
-        node: MediaConditionAllType,
-    ) -> MediaConditionAllType {
-        <MediaConditionAllType as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaConditionAllType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
-             calls [`Vec < MediaConditionAllType >::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`Vec < MediaConditionAllType >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_media_condition_all_types(
+    fn visit_mut_media_condition_all_types(
         &mut self,
-        node: Vec<MediaConditionAllType>,
-    ) -> Vec<MediaConditionAllType> {
-        <Vec<MediaConditionAllType> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<MediaConditionAllType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
-             [`MediaConditionType::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaConditionType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
-        <MediaConditionType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_condition_type(
+        &mut self,
+        node: &mut MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaConditionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOr::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaConditionWithoutOr::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_media_condition_without_or(
+    fn visit_mut_media_condition_without_or(
         &mut self,
-        node: MediaConditionWithoutOr,
-    ) -> MediaConditionWithoutOr {
-        <MediaConditionWithoutOr as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaConditionWithoutOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOrType::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaConditionWithoutOrType::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_media_condition_without_or_type(
+    fn visit_mut_media_condition_without_or_type(
         &mut self,
-        node: MediaConditionWithoutOrType,
-    ) -> MediaConditionWithoutOrType {
-        <MediaConditionWithoutOrType as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaConditionWithoutOrType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
-             method calls [`Vec < MediaConditionWithoutOrType >::fold_children_with`]. If you want \
-             to recurse, you need to call it manually."]
+             method calls [`Vec < MediaConditionWithoutOrType \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_condition_without_or_types(
+    fn visit_mut_media_condition_without_or_types(
         &mut self,
-        node: Vec<MediaConditionWithoutOrType>,
-    ) -> Vec<MediaConditionWithoutOrType> {
-        <Vec<MediaConditionWithoutOrType> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Vec < MediaConditionWithoutOrType > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
-             [`MediaFeature::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaFeature::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
-        <MediaFeature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
+        <MediaFeature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
-             [`MediaFeatureBoolean::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaFeatureBoolean::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
-        <MediaFeatureBoolean as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_feature_boolean(
+        &mut self,
+        node: &mut MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaFeatureBoolean as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
-             [`MediaFeatureName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaFeatureName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
-        <MediaFeatureName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_feature_name(
+        &mut self,
+        node: &mut MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaFeatureName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
-             [`MediaFeaturePlain::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaFeaturePlain::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
-        <MediaFeaturePlain as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_feature_plain(
+        &mut self,
+        node: &mut MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaFeaturePlain as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
-             [`MediaFeatureRange::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaFeatureRange::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
-        <MediaFeatureRange as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_feature_range(
+        &mut self,
+        node: &mut MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaFeatureRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeComparison::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaFeatureRangeComparison::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_media_feature_range_comparison(
+    fn visit_mut_media_feature_range_comparison(
         &mut self,
-        node: MediaFeatureRangeComparison,
-    ) -> MediaFeatureRangeComparison {
-        <MediaFeatureRangeComparison as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaFeatureRangeComparison as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeInterval::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaFeatureRangeInterval::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_media_feature_range_interval(
+    fn visit_mut_media_feature_range_interval(
         &mut self,
-        node: MediaFeatureRangeInterval,
-    ) -> MediaFeatureRangeInterval {
-        <MediaFeatureRangeInterval as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaFeatureRangeInterval as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
-             [`MediaFeatureValue::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaFeatureValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
-        <MediaFeatureValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_feature_value(
+        &mut self,
+        node: &mut MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaFeatureValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
-             [`MediaInParens::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaInParens::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
-        <MediaInParens as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_in_parens(
+        &mut self,
+        node: &mut MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaInParens as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
-             [`MediaNot::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaNot::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
-        <MediaNot as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
+        <MediaNot as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
-             [`MediaOr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`MediaOr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
-        <MediaOr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
+        <MediaOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
-             [`MediaQuery::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
-        <MediaQuery as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
+        <MediaQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
-             [`MediaQueryList::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaQueryList::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
-        <MediaQueryList as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_query_list(
+        &mut self,
+        node: &mut MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <MediaQueryList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
-             MediaQuery >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             MediaQuery >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
-        <Vec<MediaQuery> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
+        <Vec<MediaQuery> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
-             [`MediaType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
-        <MediaType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
+        <MediaType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
-             [`NamedNamespace::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NamedNamespace::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
-        <NamedNamespace as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_named_namespace(
+        &mut self,
+        node: &mut NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <NamedNamespace as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Namespace::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
-        <Namespace as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
+        <Namespace as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
-             [`NamespacePrefix::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NamespacePrefix::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
-        <NamespacePrefix as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_namespace_prefix(
+        &mut self,
+        node: &mut NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <NamespacePrefix as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
-             [`NamespacePrelude::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NamespacePrelude::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
-        <NamespacePrelude as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_namespace_prelude(
+        &mut self,
+        node: &mut NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <NamespacePrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
-             [`NamespacePreludeUri::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`NamespacePreludeUri::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
-        <NamespacePreludeUri as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_namespace_prelude_uri(
+        &mut self,
+        node: &mut NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <NamespacePreludeUri as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
-             [`NestingSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NestingSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
-        <NestingSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_nesting_selector(
+        &mut self,
+        node: &mut NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <NestingSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Number::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
-        <Number as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+        <Number as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
-             [`NumberType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NumberType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
-        <NumberType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
+        <NumberType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
-             calls [`Option < Box < AtRulePrelude > >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Box < AtRulePrelude > >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_at_rule_prelude(
+    fn visit_mut_opt_at_rule_prelude(
         &mut self,
-        node: Option<Box<AtRulePrelude>>,
-    ) -> Option<Box<AtRulePrelude>> {
-        <Option<Box<AtRulePrelude>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<AtRulePrelude>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::fold_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < swc_atoms :: Atom >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
-        <Option<swc_atoms::Atom> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<swc_atoms::Atom> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorMatcher >::fold_children_with`]. If you want \
-             to recurse, you need to call it manually."]
+             method calls [`Option < AttributeSelectorMatcher \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_attribute_selector_matcher(
+    fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
-        node: Option<AttributeSelectorMatcher>,
-    ) -> Option<AttributeSelectorMatcher> {
-        <Option<AttributeSelectorMatcher> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < AttributeSelectorMatcher > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorModifier >::fold_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+             method calls [`Option < AttributeSelectorModifier \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_attribute_selector_modifier(
+    fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
-        node: Option<AttributeSelectorModifier>,
-    ) -> Option<AttributeSelectorModifier> {
-        <Option<AttributeSelectorModifier> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < AttributeSelectorModifier > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
-             calls [`Option < AttributeSelectorValue >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < AttributeSelectorValue >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_attribute_selector_value(
+    fn visit_mut_opt_attribute_selector_value(
         &mut self,
-        node: Option<AttributeSelectorValue>,
-    ) -> Option<AttributeSelectorValue> {
-        <Option<AttributeSelectorValue> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < AttributeSelectorValue > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
-             [`Option < Combinator >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < Combinator >::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
-        <Option<Combinator> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_combinator(
+        &mut self,
+        node: &mut Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Combinator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
-             [`Option < ContainerName >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < ContainerName >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
-        <Option<ContainerName> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_container_name(
+        &mut self,
+        node: &mut Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<ContainerName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
-             calls [`Option < ForgivingSelectorList >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < ForgivingSelectorList >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_forgiving_selector_list(
+    fn visit_mut_opt_forgiving_selector_list(
         &mut self,
-        node: Option<ForgivingSelectorList>,
-    ) -> Option<ForgivingSelectorList> {
-        <Option<ForgivingSelectorList> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < ForgivingSelectorList > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
-             [`Option < Box < Function > >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < Box < Function > >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
-        <Option<Box<Function>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_function(
+        &mut self,
+        node: &mut Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<Function>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             Ident >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
-        <Option<Ident> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+        <Option<Ident> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
-             method calls [`Option < Box < ImportConditions > >::fold_children_with`]. If you want \
-             to recurse, you need to call it manually."]
+             method calls [`Option < Box < ImportConditions > \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_import_conditions(
+    fn visit_mut_opt_import_conditions(
         &mut self,
-        node: Option<Box<ImportConditions>>,
-    ) -> Option<Box<ImportConditions>> {
-        <Option<Box<ImportConditions>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Box < ImportConditions > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
-             calls [`Option < Box < ImportLayerName > >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Box < ImportLayerName > >::visit_mut_children_with_ast_path`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_import_layer_name(
+    fn visit_mut_opt_import_layer_name(
         &mut self,
-        node: Option<Box<ImportLayerName>>,
-    ) -> Option<Box<ImportLayerName>> {
-        <Option<Box<ImportLayerName>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Box < ImportLayerName > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
-             [`Option < ImportantFlag >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < ImportantFlag >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
-        <Option<ImportantFlag> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_important_flag(
+        &mut self,
+        node: &mut Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<ImportantFlag> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
-             method calls [`Option < Box < MediaConditionType > >::fold_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+             method calls [`Option < Box < MediaConditionType > \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_media_condition_type(
+    fn visit_mut_opt_media_condition_type(
         &mut self,
-        node: Option<Box<MediaConditionType>>,
-    ) -> Option<Box<MediaConditionType>> {
-        <Option<Box<MediaConditionType>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Box < MediaConditionType > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
-             calls [`Option < Box < MediaQueryList > >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Box < MediaQueryList > >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_media_query_list(
+    fn visit_mut_opt_media_query_list(
         &mut self,
-        node: Option<Box<MediaQueryList>>,
-    ) -> Option<Box<MediaQueryList>> {
-        <Option<Box<MediaQueryList>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<MediaQueryList>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
-             [`Option < MediaType >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < MediaType >::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
-        <Option<MediaType> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_media_type(
+        &mut self,
+        node: &mut Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<MediaType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < Namespace >::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
-        <Option<Namespace> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_namespace(
+        &mut self,
+        node: &mut Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Namespace> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
-             [`Option < NamespacePrefix >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < NamespacePrefix >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_namespace_prefix(
+    fn visit_mut_opt_namespace_prefix(
         &mut self,
-        node: Option<NamespacePrefix>,
-    ) -> Option<NamespacePrefix> {
-        <Option<NamespacePrefix> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<NamespacePrefix> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
-             [`Option < NestingSelector >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < NestingSelector >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_nesting_selector(
+    fn visit_mut_opt_nesting_selector(
         &mut self,
-        node: Option<NestingSelector>,
-    ) -> Option<NestingSelector> {
-        <Option<NestingSelector> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<NestingSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
-             Number >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             Number >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
-        <Option<Number> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
+        <Option<Number> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
-             method calls [`Option < Vec < PageSelectorPseudo > >::fold_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+             method calls [`Option < Vec < PageSelectorPseudo > \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_page_selector_pseudos(
+    fn visit_mut_opt_page_selector_pseudos(
         &mut self,
-        node: Option<Vec<PageSelectorPseudo>>,
-    ) -> Option<Vec<PageSelectorPseudo>> {
-        <Option<Vec<PageSelectorPseudo>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Vec < PageSelectorPseudo > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
-             [`Option < PageSelectorType >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < PageSelectorType >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_page_selector_type(
+    fn visit_mut_opt_page_selector_type(
         &mut self,
-        node: Option<PageSelectorType>,
-    ) -> Option<PageSelectorType> {
-        <Option<PageSelectorType> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<PageSelectorType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
              this method calls [`Option < Vec < PseudoClassSelectorChildren > \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_pseudo_class_selector_childrens(
+    fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoClassSelectorChildren>>,
-    ) -> Option<Vec<PseudoClassSelectorChildren>> {
-        <Option<Vec<PseudoClassSelectorChildren>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Vec < PseudoClassSelectorChildren > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
              default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_pseudo_element_selector_childrens(
+    fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoElementSelectorChildren>>,
-    ) -> Option<Vec<PseudoElementSelectorChildren>> {
-        <Option<Vec<PseudoElementSelectorChildren>> as FoldWith<Self>>::fold_children_with(
-            node, self,
-        )
+        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Vec < PseudoElementSelectorChildren > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
-             [`Option < SimpleBlock >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < SimpleBlock >::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
-        <Option<SimpleBlock> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_simple_block(
+        &mut self,
+        node: &mut Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<SimpleBlock> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
-             calls [`Option < Box < TypeSelector > >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Box < TypeSelector > >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_type_selector(
+    fn visit_mut_opt_type_selector(
         &mut self,
-        node: Option<Box<TypeSelector>>,
-    ) -> Option<Box<TypeSelector>> {
-        <Option<Box<TypeSelector>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<TypeSelector>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
-             calls [`Option < Vec < UrlModifier > >::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`Option < Vec < UrlModifier > >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_url_modifiers(
+    fn visit_mut_opt_url_modifiers(
         &mut self,
-        node: Option<Vec<UrlModifier>>,
-    ) -> Option<Vec<UrlModifier>> {
-        <Option<Vec<UrlModifier>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Vec<UrlModifier>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
-             [`Option < Box < UrlValue > >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < Box < UrlValue > >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
-        <Option<Box<UrlValue>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_url_value(
+        &mut self,
+        node: &mut Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<UrlValue>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
-             [`PageSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PageSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
-        <PageSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
+        <PageSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
-             [`PageSelectorList::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PageSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
-        <PageSelectorList as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_page_selector_list(
+        &mut self,
+        node: &mut PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <PageSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
-             [`PageSelectorPseudo::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`PageSelectorPseudo::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
-        <PageSelectorPseudo as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_page_selector_pseudo(
+        &mut self,
+        node: &mut PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <PageSelectorPseudo as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
-             [`Vec < PageSelectorPseudo >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Vec < PageSelectorPseudo >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_page_selector_pseudos(
+    fn visit_mut_page_selector_pseudos(
         &mut self,
-        node: Vec<PageSelectorPseudo>,
-    ) -> Vec<PageSelectorPseudo> {
-        <Vec<PageSelectorPseudo> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<PageSelectorPseudo> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
-             [`PageSelectorType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PageSelectorType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
-        <PageSelectorType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_page_selector_type(
+        &mut self,
+        node: &mut PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <PageSelectorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
-             PageSelector >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             PageSelector >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
-        <Vec<PageSelector> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_page_selectors(
+        &mut self,
+        node: &mut Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<PageSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
-             [`Percentage::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Percentage::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
-        <Percentage as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
+        <Percentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
-             [`PseudoClassSelector::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`PseudoClassSelector::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
-        <PseudoClassSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_pseudo_class_selector(
+        &mut self,
+        node: &mut PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <PseudoClassSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
-             [`PseudoClassSelectorChildren::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PseudoClassSelectorChildren::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_pseudo_class_selector_children(
+    fn visit_mut_pseudo_class_selector_children(
         &mut self,
-        node: PseudoClassSelectorChildren,
-    ) -> PseudoClassSelectorChildren {
-        <PseudoClassSelectorChildren as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <PseudoClassSelectorChildren as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoClassSelectorChildren >::fold_children_with`]. If you want \
-             to recurse, you need to call it manually."]
+             method calls [`Vec < PseudoClassSelectorChildren \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_pseudo_class_selector_childrens(
+    fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
-        node: Vec<PseudoClassSelectorChildren>,
-    ) -> Vec<PseudoClassSelectorChildren> {
-        <Vec<PseudoClassSelectorChildren> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Vec < PseudoClassSelectorChildren > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
-             [`PseudoElementSelector::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`PseudoElementSelector::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_pseudo_element_selector(
+    fn visit_mut_pseudo_element_selector(
         &mut self,
-        node: PseudoElementSelector,
-    ) -> PseudoElementSelector {
-        <PseudoElementSelector as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <PseudoElementSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
-             calls [`PseudoElementSelectorChildren::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`PseudoElementSelectorChildren::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_pseudo_element_selector_children(
+    fn visit_mut_pseudo_element_selector_children(
         &mut self,
-        node: PseudoElementSelectorChildren,
-    ) -> PseudoElementSelectorChildren {
-        <PseudoElementSelectorChildren as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < PseudoElementSelectorChildren as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoElementSelectorChildren >::fold_children_with`]. If you \
-             want to recurse, you need to call it manually."]
+             method calls [`Vec < PseudoElementSelectorChildren \
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_pseudo_element_selector_childrens(
+    fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
-        node: Vec<PseudoElementSelectorChildren>,
-    ) -> Vec<PseudoElementSelectorChildren> {
-        <Vec<PseudoElementSelectorChildren> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Vec < PseudoElementSelectorChildren > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
-             [`QualifiedRule::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`QualifiedRule::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
-        <QualifiedRule as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
+        <QualifiedRule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
-             [`QualifiedRulePrelude::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`QualifiedRulePrelude::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
-        <QualifiedRulePrelude as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_qualified_rule_prelude(
+        &mut self,
+        node: &mut QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <QualifiedRulePrelude as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
-             [`QueryInParens::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`QueryInParens::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
-        <QueryInParens as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_query_in_parens(
+        &mut self,
+        node: &mut QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <QueryInParens as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
-             [`Ratio::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Ratio::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
-        <Ratio as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
+        <Ratio as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
-             [`RelativeSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`RelativeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
-        <RelativeSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_relative_selector(
+        &mut self,
+        node: &mut RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <RelativeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
-             [`RelativeSelectorList::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`RelativeSelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
-        <RelativeSelectorList as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_relative_selector_list(
+        &mut self,
+        node: &mut RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <RelativeSelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
-             [`Vec < RelativeSelector >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < RelativeSelector >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
-        <Vec<RelativeSelector> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_relative_selectors(
+        &mut self,
+        node: &mut Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<RelativeSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
-             [`Resolution::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Resolution::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
-        <Resolution as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
+        <Resolution as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
-             [`Rule::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Rule::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_rule(&mut self, node: Rule) -> Rule {
-        <Rule as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
+        <Rule as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
-        <Vec<Rule> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
+        <Vec<Rule> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
-             [`ScopeRange::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ScopeRange::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
-        <ScopeRange as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
+        <ScopeRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
-             [`SelectorList::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SelectorList::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
-        <SelectorList as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
+        <SelectorList as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
-             [`SequenceOfCustomIdents::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SequenceOfCustomIdents::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_sequence_of_custom_idents(
+    fn visit_mut_sequence_of_custom_idents(
         &mut self,
-        node: SequenceOfCustomIdents,
-    ) -> SequenceOfCustomIdents {
-        <SequenceOfCustomIdents as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SequenceOfCustomIdents as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
-             [`SimpleBlock::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SimpleBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
-        <SimpleBlock as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
+        <SimpleBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
-             [`SizeFeature::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SizeFeature::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
-        <SizeFeature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
+        <SizeFeature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
-             [`SizeFeatureBoolean::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SizeFeatureBoolean::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
-        <SizeFeatureBoolean as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_size_feature_boolean(
+        &mut self,
+        node: &mut SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SizeFeatureBoolean as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
-             [`SizeFeatureName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SizeFeatureName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
-        <SizeFeatureName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_size_feature_name(
+        &mut self,
+        node: &mut SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SizeFeatureName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
-             [`SizeFeaturePlain::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SizeFeaturePlain::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
-        <SizeFeaturePlain as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_size_feature_plain(
+        &mut self,
+        node: &mut SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SizeFeaturePlain as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
-             [`SizeFeatureRange::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SizeFeatureRange::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
-        <SizeFeatureRange as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_size_feature_range(
+        &mut self,
+        node: &mut SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SizeFeatureRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeComparison::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SizeFeatureRangeComparison::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_size_feature_range_comparison(
+    fn visit_mut_size_feature_range_comparison(
         &mut self,
-        node: SizeFeatureRangeComparison,
-    ) -> SizeFeatureRangeComparison {
-        <SizeFeatureRangeComparison as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SizeFeatureRangeComparison as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeInterval::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SizeFeatureRangeInterval::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_size_feature_range_interval(
+    fn visit_mut_size_feature_range_interval(
         &mut self,
-        node: SizeFeatureRangeInterval,
-    ) -> SizeFeatureRangeInterval {
-        <SizeFeatureRangeInterval as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SizeFeatureRangeInterval as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
-             [`SizeFeatureValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SizeFeatureValue::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
-        <SizeFeatureValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_size_feature_value(
+        &mut self,
+        node: &mut SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SizeFeatureValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`swc_common :: Span::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
-        <swc_common::Span as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+        <swc_common::Span as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Str::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
-        <Str as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+        <Str as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
-             [`StyleBlock::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`StyleBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
-        <StyleBlock as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
+        <StyleBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
-             [`Stylesheet::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Stylesheet::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
-        <Stylesheet as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
+        <Stylesheet as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
-             [`SubclassSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SubclassSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
-        <SubclassSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_subclass_selector(
+        &mut self,
+        node: &mut SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SubclassSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
-             [`Vec < SubclassSelector >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < SubclassSelector >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
-        <Vec<SubclassSelector> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_subclass_selectors(
+        &mut self,
+        node: &mut Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<SubclassSelector> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
-             [`SupportsAnd::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SupportsAnd::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
-        <SupportsAnd as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
+        <SupportsAnd as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
-             [`SupportsCondition::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SupportsCondition::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
-        <SupportsCondition as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_supports_condition(
+        &mut self,
+        node: &mut SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SupportsCondition as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
-             [`SupportsConditionType::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SupportsConditionType::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_supports_condition_type(
+    fn visit_mut_supports_condition_type(
         &mut self,
-        node: SupportsConditionType,
-    ) -> SupportsConditionType {
-        <SupportsConditionType as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SupportsConditionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
-             calls [`Vec < SupportsConditionType >::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`Vec < SupportsConditionType >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_supports_condition_types(
+    fn visit_mut_supports_condition_types(
         &mut self,
-        node: Vec<SupportsConditionType>,
-    ) -> Vec<SupportsConditionType> {
-        <Vec<SupportsConditionType> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<SupportsConditionType> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
-             [`SupportsFeature::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SupportsFeature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
-        <SupportsFeature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_supports_feature(
+        &mut self,
+        node: &mut SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SupportsFeature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
-             [`SupportsInParens::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SupportsInParens::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
-        <SupportsInParens as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_supports_in_parens(
+        &mut self,
+        node: &mut SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SupportsInParens as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
-             [`SupportsNot::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SupportsNot::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
-        <SupportsNot as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
+        <SupportsNot as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
-             [`SupportsOr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SupportsOr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
-        <SupportsOr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
+        <SupportsOr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
-             [`TagNameSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TagNameSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
-        <TagNameSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_tag_name_selector(
+        &mut self,
+        node: &mut TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TagNameSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
-             [`Time::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Time::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_time(&mut self, node: Time) -> Time {
-        <Time as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
+        <Time as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
-             [`TimePercentage::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TimePercentage::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
-        <TimePercentage as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_time_percentage(
+        &mut self,
+        node: &mut TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TimePercentage as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Token::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_token(&mut self, node: Token) -> Token {
-        <Token as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
+        <Token as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TokenAndSpan::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
-        <TokenAndSpan as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
+        <TokenAndSpan as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
-             [`TypeSelector::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TypeSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
-        <TypeSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
+        <TypeSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
-             [`UnicodeRange::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UnicodeRange::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
-        <UnicodeRange as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
+        <UnicodeRange as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
-             [`UniversalSelector::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`UniversalSelector::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
-        <UniversalSelector as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_universal_selector(
+        &mut self,
+        node: &mut UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <UniversalSelector as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
-             [`UnknownDimension::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UnknownDimension::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
-        <UnknownDimension as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_unknown_dimension(
+        &mut self,
+        node: &mut UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <UnknownDimension as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
-             [`Url::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Url::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_url(&mut self, node: Url) -> Url {
-        <Url as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
+        <Url as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
-             [`UrlKeyValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UrlKeyValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
-        <UrlKeyValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
+        <UrlKeyValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
-             [`UrlModifier::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UrlModifier::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
-        <UrlModifier as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
+        <UrlModifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
-             UrlModifier >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             UrlModifier >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
-        <Vec<UrlModifier> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_url_modifiers(
+        &mut self,
+        node: &mut Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<UrlModifier> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
-             [`UrlValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UrlValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
-        <UrlValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
+        <UrlValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
-             [`UrlValueRaw::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UrlValueRaw::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
-        <UrlValueRaw as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
+        <UrlValueRaw as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
-             [`WqName::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`WqName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName) -> WqName {
-        <WqName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
+        <WqName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
 }
-impl<V> Fold for &mut V
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitMutAstPath for &mut V
 where
-    V: ?Sized + Fold,
+    V: ?Sized + VisitMutAstPath,
 {
     #[inline]
-    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
-        <V as Fold>::fold_absolute_color_base(&mut **self, node)
+    fn visit_mut_absolute_color_base(
+        &mut self,
+        node: &mut AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_absolute_color_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
-        <V as Fold>::fold_alpha_value(&mut **self, node)
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_alpha_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
-        <V as Fold>::fold_an_plus_b(&mut **self, node)
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_an_plus_b(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
-        <V as Fold>::fold_an_plus_b_notation(&mut **self, node)
+    fn visit_mut_an_plus_b_notation(
+        &mut self,
+        node: &mut AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle) -> Angle {
-        <V as Fold>::fold_angle(&mut **self, node)
+    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_angle(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
-        <V as Fold>::fold_angle_percentage(&mut **self, node)
+    fn visit_mut_angle_percentage(
+        &mut self,
+        node: &mut AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_angle_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
-        <V as Fold>::fold_any_namespace(&mut **self, node)
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_any_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
-        <V as Fold>::fold_at_rule(&mut **self, node)
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
-        <V as Fold>::fold_at_rule_name(&mut **self, node)
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_at_rule_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
-        <V as Fold>::fold_at_rule_prelude(&mut **self, node)
+    fn visit_mut_at_rule_prelude(
+        &mut self,
+        node: &mut AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
-        <V as Fold>::fold_atom(&mut **self, node)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
-        <V as Fold>::fold_attribute_selector(&mut **self, node)
+    fn visit_mut_attribute_selector(
+        &mut self,
+        node: &mut AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher(
+    fn visit_mut_attribute_selector_matcher(
         &mut self,
-        node: AttributeSelectorMatcher,
-    ) -> AttributeSelectorMatcher {
-        <V as Fold>::fold_attribute_selector_matcher(&mut **self, node)
+        node: &mut AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher_value(
+    fn visit_mut_attribute_selector_matcher_value(
         &mut self,
-        node: AttributeSelectorMatcherValue,
-    ) -> AttributeSelectorMatcherValue {
-        <V as Fold>::fold_attribute_selector_matcher_value(&mut **self, node)
+        node: &mut AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_attribute_selector_modifier(
+    fn visit_mut_attribute_selector_modifier(
         &mut self,
-        node: AttributeSelectorModifier,
-    ) -> AttributeSelectorModifier {
-        <V as Fold>::fold_attribute_selector_modifier(&mut **self, node)
+        node: &mut AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector_value(
+    fn visit_mut_attribute_selector_value(
         &mut self,
-        node: AttributeSelectorValue,
-    ) -> AttributeSelectorValue {
-        <V as Fold>::fold_attribute_selector_value(&mut **self, node)
+        node: &mut AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
-        <V as Fold>::fold_bin_op(&mut **self, node)
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bin_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
-        <V as Fold>::fold_calc_operator(&mut **self, node)
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
-        <V as Fold>::fold_calc_operator_type(&mut **self, node)
+    fn visit_mut_calc_operator_type(
+        &mut self,
+        node: &mut CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_operator_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
-        <V as Fold>::fold_calc_product(&mut **self, node)
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_product(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_product_or_operator(
+    fn visit_mut_calc_product_or_operator(
         &mut self,
-        node: CalcProductOrOperator,
-    ) -> CalcProductOrOperator {
-        <V as Fold>::fold_calc_product_or_operator(&mut **self, node)
+        node: &mut CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_product_or_operators(
+    fn visit_mut_calc_product_or_operators(
         &mut self,
-        node: Vec<CalcProductOrOperator>,
-    ) -> Vec<CalcProductOrOperator> {
-        <V as Fold>::fold_calc_product_or_operators(&mut **self, node)
+        node: &mut Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
-        <V as Fold>::fold_calc_sum(&mut **self, node)
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_sum(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
-        <V as Fold>::fold_calc_value(&mut **self, node)
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
-        <V as Fold>::fold_calc_value_or_operator(&mut **self, node)
+    fn visit_mut_calc_value_or_operator(
+        &mut self,
+        node: &mut CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_value_or_operators(
+    fn visit_mut_calc_value_or_operators(
         &mut self,
-        node: Vec<CalcValueOrOperator>,
-    ) -> Vec<CalcValueOrOperator> {
-        <V as Fold>::fold_calc_value_or_operators(&mut **self, node)
+        node: &mut Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
-        <V as Fold>::fold_class_selector(&mut **self, node)
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
-        <V as Fold>::fold_cmyk_component(&mut **self, node)
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_cmyk_component(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color) -> Color {
-        <V as Fold>::fold_color(&mut **self, node)
+    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
-        <V as Fold>::fold_color_profile_name(&mut **self, node)
+    fn visit_mut_color_profile_name(
+        &mut self,
+        node: &mut ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_color_profile_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
-        <V as Fold>::fold_combinator(&mut **self, node)
+    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
-        <V as Fold>::fold_combinator_value(&mut **self, node)
+    fn visit_mut_combinator_value(
+        &mut self,
+        node: &mut CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_combinator_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
-        <V as Fold>::fold_complex_selector(&mut **self, node)
+    fn visit_mut_complex_selector(
+        &mut self,
+        node: &mut ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selector_children(
+    fn visit_mut_complex_selector_children(
         &mut self,
-        node: ComplexSelectorChildren,
-    ) -> ComplexSelectorChildren {
-        <V as Fold>::fold_complex_selector_children(&mut **self, node)
+        node: &mut ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selector_childrens(
+    fn visit_mut_complex_selector_childrens(
         &mut self,
-        node: Vec<ComplexSelectorChildren>,
-    ) -> Vec<ComplexSelectorChildren> {
-        <V as Fold>::fold_complex_selector_childrens(&mut **self, node)
+        node: &mut Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
-        <V as Fold>::fold_complex_selectors(&mut **self, node)
+    fn visit_mut_complex_selectors(
+        &mut self,
+        node: &mut Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
-        <V as Fold>::fold_component_value(&mut **self, node)
+    fn visit_mut_component_value(
+        &mut self,
+        node: &mut ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_component_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
-        <V as Fold>::fold_component_values(&mut **self, node)
+    fn visit_mut_component_values(
+        &mut self,
+        node: &mut Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
-        <V as Fold>::fold_compound_selector(&mut **self, node)
+    fn visit_mut_compound_selector(
+        &mut self,
+        node: &mut CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_compound_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
-        <V as Fold>::fold_compound_selector_list(&mut **self, node)
+    fn visit_mut_compound_selector_list(
+        &mut self,
+        node: &mut CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_compound_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
-        <V as Fold>::fold_compound_selectors(&mut **self, node)
+    fn visit_mut_compound_selectors(
+        &mut self,
+        node: &mut Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_compound_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
-        <V as Fold>::fold_container_condition(&mut **self, node)
+    fn visit_mut_container_condition(
+        &mut self,
+        node: &mut ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
-        <V as Fold>::fold_container_name(&mut **self, node)
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
-        <V as Fold>::fold_container_query(&mut **self, node)
+    fn visit_mut_container_query(
+        &mut self,
+        node: &mut ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
-        <V as Fold>::fold_container_query_and(&mut **self, node)
+    fn visit_mut_container_query_and(
+        &mut self,
+        node: &mut ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
-        <V as Fold>::fold_container_query_not(&mut **self, node)
+    fn visit_mut_container_query_not(
+        &mut self,
+        node: &mut ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
-        <V as Fold>::fold_container_query_or(&mut **self, node)
+    fn visit_mut_container_query_or(
+        &mut self,
+        node: &mut ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
-        <V as Fold>::fold_container_query_type(&mut **self, node)
+    fn visit_mut_container_query_type(
+        &mut self,
+        node: &mut ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_types(
+    fn visit_mut_container_query_types(
         &mut self,
-        node: Vec<ContainerQueryType>,
-    ) -> Vec<ContainerQueryType> {
-        <V as Fold>::fold_container_query_types(&mut **self, node)
+        node: &mut Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
-        <V as Fold>::fold_custom_highlight_name(&mut **self, node)
+    fn visit_mut_custom_highlight_name(
+        &mut self,
+        node: &mut CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_highlight_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
-        <V as Fold>::fold_custom_ident(&mut **self, node)
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
-        <V as Fold>::fold_custom_idents(&mut **self, node)
+    fn visit_mut_custom_idents(
+        &mut self,
+        node: &mut Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
-        <V as Fold>::fold_custom_media_query(&mut **self, node)
+    fn visit_mut_custom_media_query(
+        &mut self,
+        node: &mut CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_media_query_media_type(
+    fn visit_mut_custom_media_query_media_type(
         &mut self,
-        node: CustomMediaQueryMediaType,
-    ) -> CustomMediaQueryMediaType {
-        <V as Fold>::fold_custom_media_query_media_type(&mut **self, node)
+        node: &mut CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
-        <V as Fold>::fold_custom_property_name(&mut **self, node)
+    fn visit_mut_custom_property_name(
+        &mut self,
+        node: &mut CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_property_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
-        <V as Fold>::fold_dashed_ident(&mut **self, node)
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_dashed_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
-        <V as Fold>::fold_declaration(&mut **self, node)
+    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_declaration(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
-        <V as Fold>::fold_declaration_name(&mut **self, node)
+    fn visit_mut_declaration_name(
+        &mut self,
+        node: &mut DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_declaration_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
-        <V as Fold>::fold_declaration_or_at_rule(&mut **self, node)
+    fn visit_mut_declaration_or_at_rule(
+        &mut self,
+        node: &mut DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
-        <V as Fold>::fold_delimiter(&mut **self, node)
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_delimiter(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
-        <V as Fold>::fold_delimiter_value(&mut **self, node)
+    fn visit_mut_delimiter_value(
+        &mut self,
+        node: &mut DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_delimiter_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
-        <V as Fold>::fold_dimension(&mut **self, node)
+    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
-        <V as Fold>::fold_dimension_token(&mut **self, node)
+    fn visit_mut_dimension_token(
+        &mut self,
+        node: &mut DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_dimension_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
-        <V as Fold>::fold_document_prelude(&mut **self, node)
+    fn visit_mut_document_prelude(
+        &mut self,
+        node: &mut DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_document_prelude_matching_function(
+    fn visit_mut_document_prelude_matching_function(
         &mut self,
-        node: DocumentPreludeMatchingFunction,
-    ) -> DocumentPreludeMatchingFunction {
-        <V as Fold>::fold_document_prelude_matching_function(&mut **self, node)
+        node: &mut DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_document_prelude_matching_functions(
+    fn visit_mut_document_prelude_matching_functions(
         &mut self,
-        node: Vec<DocumentPreludeMatchingFunction>,
-    ) -> Vec<DocumentPreludeMatchingFunction> {
-        <V as Fold>::fold_document_prelude_matching_functions(&mut **self, node)
+        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
-        <V as Fold>::fold_extension_name(&mut **self, node)
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_extension_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
-        <V as Fold>::fold_family_name(&mut **self, node)
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_family_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
-        <V as Fold>::fold_family_names(&mut **self, node)
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_family_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex) -> Flex {
-        <V as Fold>::fold_flex(&mut **self, node)
+    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_flex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_font_feature_values_prelude(
+    fn visit_mut_font_feature_values_prelude(
         &mut self,
-        node: FontFeatureValuesPrelude,
-    ) -> FontFeatureValuesPrelude {
-        <V as Fold>::fold_font_feature_values_prelude(&mut **self, node)
+        node: &mut FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_complex_selector(
+    fn visit_mut_forgiving_complex_selector(
         &mut self,
-        node: ForgivingComplexSelector,
-    ) -> ForgivingComplexSelector {
-        <V as Fold>::fold_forgiving_complex_selector(&mut **self, node)
+        node: &mut ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_complex_selectors(
+    fn visit_mut_forgiving_complex_selectors(
         &mut self,
-        node: Vec<ForgivingComplexSelector>,
-    ) -> Vec<ForgivingComplexSelector> {
-        <V as Fold>::fold_forgiving_complex_selectors(&mut **self, node)
+        node: &mut Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector(
+    fn visit_mut_forgiving_relative_selector(
         &mut self,
-        node: ForgivingRelativeSelector,
-    ) -> ForgivingRelativeSelector {
-        <V as Fold>::fold_forgiving_relative_selector(&mut **self, node)
+        node: &mut ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector_list(
+    fn visit_mut_forgiving_relative_selector_list(
         &mut self,
-        node: ForgivingRelativeSelectorList,
-    ) -> ForgivingRelativeSelectorList {
-        <V as Fold>::fold_forgiving_relative_selector_list(&mut **self, node)
+        node: &mut ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_forgiving_relative_selectors(
+    fn visit_mut_forgiving_relative_selectors(
         &mut self,
-        node: Vec<ForgivingRelativeSelector>,
-    ) -> Vec<ForgivingRelativeSelector> {
-        <V as Fold>::fold_forgiving_relative_selectors(&mut **self, node)
+        node: &mut Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_forgiving_selector_list(
+    fn visit_mut_forgiving_selector_list(
         &mut self,
-        node: ForgivingSelectorList,
-    ) -> ForgivingSelectorList {
-        <V as Fold>::fold_forgiving_selector_list(&mut **self, node)
+        node: &mut ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
-        <V as Fold>::fold_frequency(&mut **self, node)
+    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_frequency(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
-        <V as Fold>::fold_frequency_percentage(&mut **self, node)
+    fn visit_mut_frequency_percentage(
+        &mut self,
+        node: &mut FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_frequency_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
-        <V as Fold>::fold_function(&mut **self, node)
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
-        <V as Fold>::fold_function_name(&mut **self, node)
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
-        <V as Fold>::fold_general_enclosed(&mut **self, node)
+    fn visit_mut_general_enclosed(
+        &mut self,
+        node: &mut GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_general_enclosed(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
-        <V as Fold>::fold_hex_color(&mut **self, node)
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_hex_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue) -> Hue {
-        <V as Fold>::fold_hue(&mut **self, node)
+    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_hue(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
-        <V as Fold>::fold_id_selector(&mut **self, node)
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_id_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
-        <V as Fold>::fold_ident(&mut **self, node)
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
-        <V as Fold>::fold_idents(&mut **self, node)
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
-        <V as Fold>::fold_import_conditions(&mut **self, node)
+    fn visit_mut_import_conditions(
+        &mut self,
+        node: &mut ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
-        <V as Fold>::fold_import_href(&mut **self, node)
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_href(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
-        <V as Fold>::fold_import_layer_name(&mut **self, node)
+    fn visit_mut_import_layer_name(
+        &mut self,
+        node: &mut ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
-        <V as Fold>::fold_import_prelude(&mut **self, node)
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
-        <V as Fold>::fold_important_flag(&mut **self, node)
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer) -> Integer {
-        <V as Fold>::fold_integer(&mut **self, node)
+    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_integer(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
-        <V as Fold>::fold_keyframe_block(&mut **self, node)
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
-        <V as Fold>::fold_keyframe_selector(&mut **self, node)
+    fn visit_mut_keyframe_selector(
+        &mut self,
+        node: &mut KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
-        <V as Fold>::fold_keyframe_selectors(&mut **self, node)
+    fn visit_mut_keyframe_selectors(
+        &mut self,
+        node: &mut Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
-        <V as Fold>::fold_keyframes_name(&mut **self, node)
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_function(
+    fn visit_mut_keyframes_pseudo_function(
         &mut self,
-        node: KeyframesPseudoFunction,
-    ) -> KeyframesPseudoFunction {
-        <V as Fold>::fold_keyframes_pseudo_function(&mut **self, node)
+        node: &mut KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_prefix(
+    fn visit_mut_keyframes_pseudo_prefix(
         &mut self,
-        node: KeyframesPseudoPrefix,
-    ) -> KeyframesPseudoPrefix {
-        <V as Fold>::fold_keyframes_pseudo_prefix(&mut **self, node)
+        node: &mut KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
-        <V as Fold>::fold_layer_name(&mut **self, node)
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
-        <V as Fold>::fold_layer_name_list(&mut **self, node)
+    fn visit_mut_layer_name_list(
+        &mut self,
+        node: &mut LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_layer_name_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
-        <V as Fold>::fold_layer_names(&mut **self, node)
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
-        <V as Fold>::fold_layer_prelude(&mut **self, node)
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length) -> Length {
-        <V as Fold>::fold_length(&mut **self, node)
+    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_length(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
-        <V as Fold>::fold_length_percentage(&mut **self, node)
+    fn visit_mut_length_percentage(
+        &mut self,
+        node: &mut LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_length_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_list_of_component_values(
+    fn visit_mut_list_of_component_values(
         &mut self,
-        node: ListOfComponentValues,
-    ) -> ListOfComponentValues {
-        <V as Fold>::fold_list_of_component_values(&mut **self, node)
+        node: &mut ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_list_of_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
-        <V as Fold>::fold_media_and(&mut **self, node)
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
-        <V as Fold>::fold_media_condition(&mut **self, node)
+    fn visit_mut_media_condition(
+        &mut self,
+        node: &mut MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_all_type(
+    fn visit_mut_media_condition_all_type(
         &mut self,
-        node: MediaConditionAllType,
-    ) -> MediaConditionAllType {
-        <V as Fold>::fold_media_condition_all_type(&mut **self, node)
+        node: &mut MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_all_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_all_types(
+    fn visit_mut_media_condition_all_types(
         &mut self,
-        node: Vec<MediaConditionAllType>,
-    ) -> Vec<MediaConditionAllType> {
-        <V as Fold>::fold_media_condition_all_types(&mut **self, node)
+        node: &mut Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_all_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
-        <V as Fold>::fold_media_condition_type(&mut **self, node)
+    fn visit_mut_media_condition_type(
+        &mut self,
+        node: &mut MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_without_or(
+    fn visit_mut_media_condition_without_or(
         &mut self,
-        node: MediaConditionWithoutOr,
-    ) -> MediaConditionWithoutOr {
-        <V as Fold>::fold_media_condition_without_or(&mut **self, node)
+        node: &mut MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_without_or_type(
+    fn visit_mut_media_condition_without_or_type(
         &mut self,
-        node: MediaConditionWithoutOrType,
-    ) -> MediaConditionWithoutOrType {
-        <V as Fold>::fold_media_condition_without_or_type(&mut **self, node)
+        node: &mut MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_condition_without_or_types(
+    fn visit_mut_media_condition_without_or_types(
         &mut self,
-        node: Vec<MediaConditionWithoutOrType>,
-    ) -> Vec<MediaConditionWithoutOrType> {
-        <V as Fold>::fold_media_condition_without_or_types(&mut **self, node)
+        node: &mut Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
-        <V as Fold>::fold_media_feature(&mut **self, node)
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
-        <V as Fold>::fold_media_feature_boolean(&mut **self, node)
+    fn visit_mut_media_feature_boolean(
+        &mut self,
+        node: &mut MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
-        <V as Fold>::fold_media_feature_name(&mut **self, node)
+    fn visit_mut_media_feature_name(
+        &mut self,
+        node: &mut MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
-        <V as Fold>::fold_media_feature_plain(&mut **self, node)
+    fn visit_mut_media_feature_plain(
+        &mut self,
+        node: &mut MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
-        <V as Fold>::fold_media_feature_range(&mut **self, node)
+    fn visit_mut_media_feature_range(
+        &mut self,
+        node: &mut MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_range_comparison(
+    fn visit_mut_media_feature_range_comparison(
         &mut self,
-        node: MediaFeatureRangeComparison,
-    ) -> MediaFeatureRangeComparison {
-        <V as Fold>::fold_media_feature_range_comparison(&mut **self, node)
+        node: &mut MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_feature_range_interval(
+    fn visit_mut_media_feature_range_interval(
         &mut self,
-        node: MediaFeatureRangeInterval,
-    ) -> MediaFeatureRangeInterval {
-        <V as Fold>::fold_media_feature_range_interval(&mut **self, node)
+        node: &mut MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
-        <V as Fold>::fold_media_feature_value(&mut **self, node)
+    fn visit_mut_media_feature_value(
+        &mut self,
+        node: &mut MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
-        <V as Fold>::fold_media_in_parens(&mut **self, node)
+    fn visit_mut_media_in_parens(
+        &mut self,
+        node: &mut MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
-        <V as Fold>::fold_media_not(&mut **self, node)
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
-        <V as Fold>::fold_media_or(&mut **self, node)
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
-        <V as Fold>::fold_media_query(&mut **self, node)
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
-        <V as Fold>::fold_media_query_list(&mut **self, node)
+    fn visit_mut_media_query_list(
+        &mut self,
+        node: &mut MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
-        <V as Fold>::fold_media_querys(&mut **self, node)
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_querys(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
-        <V as Fold>::fold_media_type(&mut **self, node)
+    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
-        <V as Fold>::fold_named_namespace(&mut **self, node)
+    fn visit_mut_named_namespace(
+        &mut self,
+        node: &mut NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_named_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
-        <V as Fold>::fold_namespace(&mut **self, node)
+    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
-        <V as Fold>::fold_namespace_prefix(&mut **self, node)
+    fn visit_mut_namespace_prefix(
+        &mut self,
+        node: &mut NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
-        <V as Fold>::fold_namespace_prelude(&mut **self, node)
+    fn visit_mut_namespace_prelude(
+        &mut self,
+        node: &mut NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
-        <V as Fold>::fold_namespace_prelude_uri(&mut **self, node)
+    fn visit_mut_namespace_prelude_uri(
+        &mut self,
+        node: &mut NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
-        <V as Fold>::fold_nesting_selector(&mut **self, node)
+    fn visit_mut_nesting_selector(
+        &mut self,
+        node: &mut NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
-        <V as Fold>::fold_number(&mut **self, node)
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
-        <V as Fold>::fold_number_type(&mut **self, node)
+    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_at_rule_prelude(
+    fn visit_mut_opt_at_rule_prelude(
         &mut self,
-        node: Option<Box<AtRulePrelude>>,
-    ) -> Option<Box<AtRulePrelude>> {
-        <V as Fold>::fold_opt_at_rule_prelude(&mut **self, node)
+        node: &mut Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
-        <V as Fold>::fold_opt_atom(&mut **self, node)
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_matcher(
+    fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
-        node: Option<AttributeSelectorMatcher>,
-    ) -> Option<AttributeSelectorMatcher> {
-        <V as Fold>::fold_opt_attribute_selector_matcher(&mut **self, node)
+        node: &mut Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_modifier(
+    fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
-        node: Option<AttributeSelectorModifier>,
-    ) -> Option<AttributeSelectorModifier> {
-        <V as Fold>::fold_opt_attribute_selector_modifier(&mut **self, node)
+        node: &mut Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_value(
+    fn visit_mut_opt_attribute_selector_value(
         &mut self,
-        node: Option<AttributeSelectorValue>,
-    ) -> Option<AttributeSelectorValue> {
-        <V as Fold>::fold_opt_attribute_selector_value(&mut **self, node)
+        node: &mut Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
-        <V as Fold>::fold_opt_combinator(&mut **self, node)
+    fn visit_mut_opt_combinator(
+        &mut self,
+        node: &mut Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
-        <V as Fold>::fold_opt_container_name(&mut **self, node)
+    fn visit_mut_opt_container_name(
+        &mut self,
+        node: &mut Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_forgiving_selector_list(
+    fn visit_mut_opt_forgiving_selector_list(
         &mut self,
-        node: Option<ForgivingSelectorList>,
-    ) -> Option<ForgivingSelectorList> {
-        <V as Fold>::fold_opt_forgiving_selector_list(&mut **self, node)
+        node: &mut Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
-        <V as Fold>::fold_opt_function(&mut **self, node)
+    fn visit_mut_opt_function(
+        &mut self,
+        node: &mut Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
-        <V as Fold>::fold_opt_ident(&mut **self, node)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_import_conditions(
+    fn visit_mut_opt_import_conditions(
         &mut self,
-        node: Option<Box<ImportConditions>>,
-    ) -> Option<Box<ImportConditions>> {
-        <V as Fold>::fold_opt_import_conditions(&mut **self, node)
+        node: &mut Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_import_layer_name(
+    fn visit_mut_opt_import_layer_name(
         &mut self,
-        node: Option<Box<ImportLayerName>>,
-    ) -> Option<Box<ImportLayerName>> {
-        <V as Fold>::fold_opt_import_layer_name(&mut **self, node)
+        node: &mut Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
-        <V as Fold>::fold_opt_important_flag(&mut **self, node)
+    fn visit_mut_opt_important_flag(
+        &mut self,
+        node: &mut Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_media_condition_type(
+    fn visit_mut_opt_media_condition_type(
         &mut self,
-        node: Option<Box<MediaConditionType>>,
-    ) -> Option<Box<MediaConditionType>> {
-        <V as Fold>::fold_opt_media_condition_type(&mut **self, node)
+        node: &mut Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_media_query_list(
+    fn visit_mut_opt_media_query_list(
         &mut self,
-        node: Option<Box<MediaQueryList>>,
-    ) -> Option<Box<MediaQueryList>> {
-        <V as Fold>::fold_opt_media_query_list(&mut **self, node)
+        node: &mut Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
-        <V as Fold>::fold_opt_media_type(&mut **self, node)
+    fn visit_mut_opt_media_type(
+        &mut self,
+        node: &mut Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
-        <V as Fold>::fold_opt_namespace(&mut **self, node)
+    fn visit_mut_opt_namespace(
+        &mut self,
+        node: &mut Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_namespace_prefix(
+    fn visit_mut_opt_namespace_prefix(
         &mut self,
-        node: Option<NamespacePrefix>,
-    ) -> Option<NamespacePrefix> {
-        <V as Fold>::fold_opt_namespace_prefix(&mut **self, node)
+        node: &mut Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_nesting_selector(
+    fn visit_mut_opt_nesting_selector(
         &mut self,
-        node: Option<NestingSelector>,
-    ) -> Option<NestingSelector> {
-        <V as Fold>::fold_opt_nesting_selector(&mut **self, node)
+        node: &mut Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
-        <V as Fold>::fold_opt_number(&mut **self, node)
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_page_selector_pseudos(
+    fn visit_mut_opt_page_selector_pseudos(
         &mut self,
-        node: Option<Vec<PageSelectorPseudo>>,
-    ) -> Option<Vec<PageSelectorPseudo>> {
-        <V as Fold>::fold_opt_page_selector_pseudos(&mut **self, node)
+        node: &mut Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_page_selector_type(
+    fn visit_mut_opt_page_selector_type(
         &mut self,
-        node: Option<PageSelectorType>,
-    ) -> Option<PageSelectorType> {
-        <V as Fold>::fold_opt_page_selector_type(&mut **self, node)
+        node: &mut Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_pseudo_class_selector_childrens(
+    fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoClassSelectorChildren>>,
-    ) -> Option<Vec<PseudoClassSelectorChildren>> {
-        <V as Fold>::fold_opt_pseudo_class_selector_childrens(&mut **self, node)
+        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_pseudo_element_selector_childrens(
+    fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoElementSelectorChildren>>,
-    ) -> Option<Vec<PseudoElementSelectorChildren>> {
-        <V as Fold>::fold_opt_pseudo_element_selector_childrens(&mut **self, node)
+        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
-        <V as Fold>::fold_opt_simple_block(&mut **self, node)
+    fn visit_mut_opt_simple_block(
+        &mut self,
+        node: &mut Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_type_selector(
+    fn visit_mut_opt_type_selector(
         &mut self,
-        node: Option<Box<TypeSelector>>,
-    ) -> Option<Box<TypeSelector>> {
-        <V as Fold>::fold_opt_type_selector(&mut **self, node)
+        node: &mut Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_url_modifiers(
+    fn visit_mut_opt_url_modifiers(
         &mut self,
-        node: Option<Vec<UrlModifier>>,
-    ) -> Option<Vec<UrlModifier>> {
-        <V as Fold>::fold_opt_url_modifiers(&mut **self, node)
+        node: &mut Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
-        <V as Fold>::fold_opt_url_value(&mut **self, node)
+    fn visit_mut_opt_url_value(
+        &mut self,
+        node: &mut Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
-        <V as Fold>::fold_page_selector(&mut **self, node)
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
-        <V as Fold>::fold_page_selector_list(&mut **self, node)
+    fn visit_mut_page_selector_list(
+        &mut self,
+        node: &mut PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
-        <V as Fold>::fold_page_selector_pseudo(&mut **self, node)
+    fn visit_mut_page_selector_pseudo(
+        &mut self,
+        node: &mut PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_pseudos(
+    fn visit_mut_page_selector_pseudos(
         &mut self,
-        node: Vec<PageSelectorPseudo>,
-    ) -> Vec<PageSelectorPseudo> {
-        <V as Fold>::fold_page_selector_pseudos(&mut **self, node)
+        node: &mut Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
-        <V as Fold>::fold_page_selector_type(&mut **self, node)
+    fn visit_mut_page_selector_type(
+        &mut self,
+        node: &mut PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
-        <V as Fold>::fold_page_selectors(&mut **self, node)
+    fn visit_mut_page_selectors(
+        &mut self,
+        node: &mut Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
-        <V as Fold>::fold_percentage(&mut **self, node)
+    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
-        <V as Fold>::fold_pseudo_class_selector(&mut **self, node)
+    fn visit_mut_pseudo_class_selector(
+        &mut self,
+        node: &mut PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_children(
+    fn visit_mut_pseudo_class_selector_children(
         &mut self,
-        node: PseudoClassSelectorChildren,
-    ) -> PseudoClassSelectorChildren {
-        <V as Fold>::fold_pseudo_class_selector_children(&mut **self, node)
+        node: &mut PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_childrens(
+    fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
-        node: Vec<PseudoClassSelectorChildren>,
-    ) -> Vec<PseudoClassSelectorChildren> {
-        <V as Fold>::fold_pseudo_class_selector_childrens(&mut **self, node)
+        node: &mut Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_pseudo_element_selector(
+    fn visit_mut_pseudo_element_selector(
         &mut self,
-        node: PseudoElementSelector,
-    ) -> PseudoElementSelector {
-        <V as Fold>::fold_pseudo_element_selector(&mut **self, node)
+        node: &mut PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_children(
+    fn visit_mut_pseudo_element_selector_children(
         &mut self,
-        node: PseudoElementSelectorChildren,
-    ) -> PseudoElementSelectorChildren {
-        <V as Fold>::fold_pseudo_element_selector_children(&mut **self, node)
+        node: &mut PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_childrens(
+    fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
-        node: Vec<PseudoElementSelectorChildren>,
-    ) -> Vec<PseudoElementSelectorChildren> {
-        <V as Fold>::fold_pseudo_element_selector_childrens(&mut **self, node)
+        node: &mut Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
-        <V as Fold>::fold_qualified_rule(&mut **self, node)
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_qualified_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
-        <V as Fold>::fold_qualified_rule_prelude(&mut **self, node)
+    fn visit_mut_qualified_rule_prelude(
+        &mut self,
+        node: &mut QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
-        <V as Fold>::fold_query_in_parens(&mut **self, node)
+    fn visit_mut_query_in_parens(
+        &mut self,
+        node: &mut QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_query_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
-        <V as Fold>::fold_ratio(&mut **self, node)
+    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ratio(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
-        <V as Fold>::fold_relative_selector(&mut **self, node)
+    fn visit_mut_relative_selector(
+        &mut self,
+        node: &mut RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
-        <V as Fold>::fold_relative_selector_list(&mut **self, node)
+    fn visit_mut_relative_selector_list(
+        &mut self,
+        node: &mut RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
-        <V as Fold>::fold_relative_selectors(&mut **self, node)
+    fn visit_mut_relative_selectors(
+        &mut self,
+        node: &mut Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
-        <V as Fold>::fold_resolution(&mut **self, node)
+    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_resolution(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule) -> Rule {
-        <V as Fold>::fold_rule(&mut **self, node)
+    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
-        <V as Fold>::fold_rules(&mut **self, node)
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rules(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
-        <V as Fold>::fold_scope_range(&mut **self, node)
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_scope_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
-        <V as Fold>::fold_selector_list(&mut **self, node)
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_sequence_of_custom_idents(
+    fn visit_mut_sequence_of_custom_idents(
         &mut self,
-        node: SequenceOfCustomIdents,
-    ) -> SequenceOfCustomIdents {
-        <V as Fold>::fold_sequence_of_custom_idents(&mut **self, node)
+        node: &mut SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
-        <V as Fold>::fold_simple_block(&mut **self, node)
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
-        <V as Fold>::fold_size_feature(&mut **self, node)
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
-        <V as Fold>::fold_size_feature_boolean(&mut **self, node)
+    fn visit_mut_size_feature_boolean(
+        &mut self,
+        node: &mut SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
-        <V as Fold>::fold_size_feature_name(&mut **self, node)
+    fn visit_mut_size_feature_name(
+        &mut self,
+        node: &mut SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
-        <V as Fold>::fold_size_feature_plain(&mut **self, node)
+    fn visit_mut_size_feature_plain(
+        &mut self,
+        node: &mut SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
-        <V as Fold>::fold_size_feature_range(&mut **self, node)
+    fn visit_mut_size_feature_range(
+        &mut self,
+        node: &mut SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_range_comparison(
+    fn visit_mut_size_feature_range_comparison(
         &mut self,
-        node: SizeFeatureRangeComparison,
-    ) -> SizeFeatureRangeComparison {
-        <V as Fold>::fold_size_feature_range_comparison(&mut **self, node)
+        node: &mut SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_size_feature_range_interval(
+    fn visit_mut_size_feature_range_interval(
         &mut self,
-        node: SizeFeatureRangeInterval,
-    ) -> SizeFeatureRangeInterval {
-        <V as Fold>::fold_size_feature_range_interval(&mut **self, node)
+        node: &mut SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
-        <V as Fold>::fold_size_feature_value(&mut **self, node)
+    fn visit_mut_size_feature_value(
+        &mut self,
+        node: &mut SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
-        <V as Fold>::fold_span(&mut **self, node)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
-        <V as Fold>::fold_str(&mut **self, node)
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
-        <V as Fold>::fold_style_block(&mut **self, node)
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_style_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
-        <V as Fold>::fold_stylesheet(&mut **self, node)
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stylesheet(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
-        <V as Fold>::fold_subclass_selector(&mut **self, node)
+    fn visit_mut_subclass_selector(
+        &mut self,
+        node: &mut SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_subclass_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
-        <V as Fold>::fold_subclass_selectors(&mut **self, node)
+    fn visit_mut_subclass_selectors(
+        &mut self,
+        node: &mut Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_subclass_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
-        <V as Fold>::fold_supports_and(&mut **self, node)
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
-        <V as Fold>::fold_supports_condition(&mut **self, node)
+    fn visit_mut_supports_condition(
+        &mut self,
+        node: &mut SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_condition_type(
+    fn visit_mut_supports_condition_type(
         &mut self,
-        node: SupportsConditionType,
-    ) -> SupportsConditionType {
-        <V as Fold>::fold_supports_condition_type(&mut **self, node)
+        node: &mut SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_condition_types(
+    fn visit_mut_supports_condition_types(
         &mut self,
-        node: Vec<SupportsConditionType>,
-    ) -> Vec<SupportsConditionType> {
-        <V as Fold>::fold_supports_condition_types(&mut **self, node)
+        node: &mut Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
-        <V as Fold>::fold_supports_feature(&mut **self, node)
+    fn visit_mut_supports_feature(
+        &mut self,
+        node: &mut SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
-        <V as Fold>::fold_supports_in_parens(&mut **self, node)
+    fn visit_mut_supports_in_parens(
+        &mut self,
+        node: &mut SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
-        <V as Fold>::fold_supports_not(&mut **self, node)
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
-        <V as Fold>::fold_supports_or(&mut **self, node)
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
-        <V as Fold>::fold_tag_name_selector(&mut **self, node)
+    fn visit_mut_tag_name_selector(
+        &mut self,
+        node: &mut TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_tag_name_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time) -> Time {
-        <V as Fold>::fold_time(&mut **self, node)
+    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_time(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
-        <V as Fold>::fold_time_percentage(&mut **self, node)
+    fn visit_mut_time_percentage(
+        &mut self,
+        node: &mut TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_time_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token) -> Token {
-        <V as Fold>::fold_token(&mut **self, node)
+    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
-        <V as Fold>::fold_token_and_span(&mut **self, node)
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_token_and_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
-        <V as Fold>::fold_type_selector(&mut **self, node)
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
-        <V as Fold>::fold_unicode_range(&mut **self, node)
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unicode_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
-        <V as Fold>::fold_universal_selector(&mut **self, node)
+    fn visit_mut_universal_selector(
+        &mut self,
+        node: &mut UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_universal_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
-        <V as Fold>::fold_unknown_dimension(&mut **self, node)
+    fn visit_mut_unknown_dimension(
+        &mut self,
+        node: &mut UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_unknown_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url) -> Url {
-        <V as Fold>::fold_url(&mut **self, node)
+    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
-        <V as Fold>::fold_url_key_value(&mut **self, node)
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_key_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
-        <V as Fold>::fold_url_modifier(&mut **self, node)
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
-        <V as Fold>::fold_url_modifiers(&mut **self, node)
+    fn visit_mut_url_modifiers(
+        &mut self,
+        node: &mut Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
-        <V as Fold>::fold_url_value(&mut **self, node)
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
-        <V as Fold>::fold_url_value_raw(&mut **self, node)
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_value_raw(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName) -> WqName {
-        <V as Fold>::fold_wq_name(&mut **self, node)
+    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_wq_name(&mut **self, node, __ast_path)
     }
 }
-impl<V> Fold for Box<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitMutAstPath for Box<V>
 where
-    V: ?Sized + Fold,
+    V: ?Sized + VisitMutAstPath,
 {
     #[inline]
-    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
-        <V as Fold>::fold_absolute_color_base(&mut **self, node)
+    fn visit_mut_absolute_color_base(
+        &mut self,
+        node: &mut AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_absolute_color_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
-        <V as Fold>::fold_alpha_value(&mut **self, node)
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_alpha_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
-        <V as Fold>::fold_an_plus_b(&mut **self, node)
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_an_plus_b(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
-        <V as Fold>::fold_an_plus_b_notation(&mut **self, node)
+    fn visit_mut_an_plus_b_notation(
+        &mut self,
+        node: &mut AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle) -> Angle {
-        <V as Fold>::fold_angle(&mut **self, node)
+    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_angle(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
-        <V as Fold>::fold_angle_percentage(&mut **self, node)
+    fn visit_mut_angle_percentage(
+        &mut self,
+        node: &mut AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_angle_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
-        <V as Fold>::fold_any_namespace(&mut **self, node)
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_any_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
-        <V as Fold>::fold_at_rule(&mut **self, node)
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
-        <V as Fold>::fold_at_rule_name(&mut **self, node)
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_at_rule_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
-        <V as Fold>::fold_at_rule_prelude(&mut **self, node)
+    fn visit_mut_at_rule_prelude(
+        &mut self,
+        node: &mut AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
-        <V as Fold>::fold_atom(&mut **self, node)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
-        <V as Fold>::fold_attribute_selector(&mut **self, node)
+    fn visit_mut_attribute_selector(
+        &mut self,
+        node: &mut AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher(
+    fn visit_mut_attribute_selector_matcher(
         &mut self,
-        node: AttributeSelectorMatcher,
-    ) -> AttributeSelectorMatcher {
-        <V as Fold>::fold_attribute_selector_matcher(&mut **self, node)
+        node: &mut AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher_value(
+    fn visit_mut_attribute_selector_matcher_value(
         &mut self,
-        node: AttributeSelectorMatcherValue,
-    ) -> AttributeSelectorMatcherValue {
-        <V as Fold>::fold_attribute_selector_matcher_value(&mut **self, node)
+        node: &mut AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_attribute_selector_modifier(
+    fn visit_mut_attribute_selector_modifier(
         &mut self,
-        node: AttributeSelectorModifier,
-    ) -> AttributeSelectorModifier {
-        <V as Fold>::fold_attribute_selector_modifier(&mut **self, node)
+        node: &mut AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_attribute_selector_value(
+    fn visit_mut_attribute_selector_value(
         &mut self,
-        node: AttributeSelectorValue,
-    ) -> AttributeSelectorValue {
-        <V as Fold>::fold_attribute_selector_value(&mut **self, node)
+        node: &mut AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
-        <V as Fold>::fold_bin_op(&mut **self, node)
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bin_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
-        <V as Fold>::fold_calc_operator(&mut **self, node)
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
-        <V as Fold>::fold_calc_operator_type(&mut **self, node)
+    fn visit_mut_calc_operator_type(
+        &mut self,
+        node: &mut CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_operator_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
-        <V as Fold>::fold_calc_product(&mut **self, node)
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_product(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_product_or_operator(
+    fn visit_mut_calc_product_or_operator(
         &mut self,
-        node: CalcProductOrOperator,
-    ) -> CalcProductOrOperator {
-        <V as Fold>::fold_calc_product_or_operator(&mut **self, node)
+        node: &mut CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_product_or_operators(
+    fn visit_mut_calc_product_or_operators(
         &mut self,
-        node: Vec<CalcProductOrOperator>,
-    ) -> Vec<CalcProductOrOperator> {
-        <V as Fold>::fold_calc_product_or_operators(&mut **self, node)
+        node: &mut Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
-        <V as Fold>::fold_calc_sum(&mut **self, node)
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_sum(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
-        <V as Fold>::fold_calc_value(&mut **self, node)
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
-        <V as Fold>::fold_calc_value_or_operator(&mut **self, node)
+    fn visit_mut_calc_value_or_operator(
+        &mut self,
+        node: &mut CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_calc_value_or_operators(
+    fn visit_mut_calc_value_or_operators(
         &mut self,
-        node: Vec<CalcValueOrOperator>,
-    ) -> Vec<CalcValueOrOperator> {
-        <V as Fold>::fold_calc_value_or_operators(&mut **self, node)
+        node: &mut Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
-        <V as Fold>::fold_class_selector(&mut **self, node)
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
-        <V as Fold>::fold_cmyk_component(&mut **self, node)
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_cmyk_component(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color) -> Color {
-        <V as Fold>::fold_color(&mut **self, node)
+    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
-        <V as Fold>::fold_color_profile_name(&mut **self, node)
+    fn visit_mut_color_profile_name(
+        &mut self,
+        node: &mut ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_color_profile_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
-        <V as Fold>::fold_combinator(&mut **self, node)
+    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
-        <V as Fold>::fold_combinator_value(&mut **self, node)
+    fn visit_mut_combinator_value(
+        &mut self,
+        node: &mut CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_combinator_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
-        <V as Fold>::fold_complex_selector(&mut **self, node)
+    fn visit_mut_complex_selector(
+        &mut self,
+        node: &mut ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selector_children(
+    fn visit_mut_complex_selector_children(
         &mut self,
-        node: ComplexSelectorChildren,
-    ) -> ComplexSelectorChildren {
-        <V as Fold>::fold_complex_selector_children(&mut **self, node)
+        node: &mut ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selector_childrens(
+    fn visit_mut_complex_selector_childrens(
         &mut self,
-        node: Vec<ComplexSelectorChildren>,
-    ) -> Vec<ComplexSelectorChildren> {
-        <V as Fold>::fold_complex_selector_childrens(&mut **self, node)
+        node: &mut Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
-        <V as Fold>::fold_complex_selectors(&mut **self, node)
+    fn visit_mut_complex_selectors(
+        &mut self,
+        node: &mut Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
-        <V as Fold>::fold_component_value(&mut **self, node)
+    fn visit_mut_component_value(
+        &mut self,
+        node: &mut ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_component_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
-        <V as Fold>::fold_component_values(&mut **self, node)
+    fn visit_mut_component_values(
+        &mut self,
+        node: &mut Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
-        <V as Fold>::fold_compound_selector(&mut **self, node)
+    fn visit_mut_compound_selector(
+        &mut self,
+        node: &mut CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_compound_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
-        <V as Fold>::fold_compound_selector_list(&mut **self, node)
+    fn visit_mut_compound_selector_list(
+        &mut self,
+        node: &mut CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_compound_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
-        <V as Fold>::fold_compound_selectors(&mut **self, node)
+    fn visit_mut_compound_selectors(
+        &mut self,
+        node: &mut Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_compound_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
-        <V as Fold>::fold_container_condition(&mut **self, node)
+    fn visit_mut_container_condition(
+        &mut self,
+        node: &mut ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
-        <V as Fold>::fold_container_name(&mut **self, node)
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
-        <V as Fold>::fold_container_query(&mut **self, node)
+    fn visit_mut_container_query(
+        &mut self,
+        node: &mut ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
-        <V as Fold>::fold_container_query_and(&mut **self, node)
+    fn visit_mut_container_query_and(
+        &mut self,
+        node: &mut ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
-        <V as Fold>::fold_container_query_not(&mut **self, node)
+    fn visit_mut_container_query_not(
+        &mut self,
+        node: &mut ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
-        <V as Fold>::fold_container_query_or(&mut **self, node)
+    fn visit_mut_container_query_or(
+        &mut self,
+        node: &mut ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
-        <V as Fold>::fold_container_query_type(&mut **self, node)
+    fn visit_mut_container_query_type(
+        &mut self,
+        node: &mut ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_container_query_types(
+    fn visit_mut_container_query_types(
         &mut self,
-        node: Vec<ContainerQueryType>,
-    ) -> Vec<ContainerQueryType> {
-        <V as Fold>::fold_container_query_types(&mut **self, node)
+        node: &mut Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_container_query_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
-        <V as Fold>::fold_custom_highlight_name(&mut **self, node)
+    fn visit_mut_custom_highlight_name(
+        &mut self,
+        node: &mut CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_highlight_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
-        <V as Fold>::fold_custom_ident(&mut **self, node)
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
-        <V as Fold>::fold_custom_idents(&mut **self, node)
+    fn visit_mut_custom_idents(
+        &mut self,
+        node: &mut Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
-        <V as Fold>::fold_custom_media_query(&mut **self, node)
+    fn visit_mut_custom_media_query(
+        &mut self,
+        node: &mut CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_custom_media_query_media_type(
+    fn visit_mut_custom_media_query_media_type(
         &mut self,
-        node: CustomMediaQueryMediaType,
-    ) -> CustomMediaQueryMediaType {
-        <V as Fold>::fold_custom_media_query_media_type(&mut **self, node)
+        node: &mut CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
-        <V as Fold>::fold_custom_property_name(&mut **self, node)
+    fn visit_mut_custom_property_name(
+        &mut self,
+        node: &mut CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_custom_property_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
-        <V as Fold>::fold_dashed_ident(&mut **self, node)
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_dashed_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
-        <V as Fold>::fold_declaration(&mut **self, node)
+    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_declaration(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
-        <V as Fold>::fold_declaration_name(&mut **self, node)
+    fn visit_mut_declaration_name(
+        &mut self,
+        node: &mut DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_declaration_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
-        <V as Fold>::fold_declaration_or_at_rule(&mut **self, node)
+    fn visit_mut_declaration_or_at_rule(
+        &mut self,
+        node: &mut DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
-        <V as Fold>::fold_delimiter(&mut **self, node)
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_delimiter(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
-        <V as Fold>::fold_delimiter_value(&mut **self, node)
+    fn visit_mut_delimiter_value(
+        &mut self,
+        node: &mut DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_delimiter_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
-        <V as Fold>::fold_dimension(&mut **self, node)
+    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
-        <V as Fold>::fold_dimension_token(&mut **self, node)
+    fn visit_mut_dimension_token(
+        &mut self,
+        node: &mut DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_dimension_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
-        <V as Fold>::fold_document_prelude(&mut **self, node)
+    fn visit_mut_document_prelude(
+        &mut self,
+        node: &mut DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_document_prelude_matching_function(
+    fn visit_mut_document_prelude_matching_function(
         &mut self,
-        node: DocumentPreludeMatchingFunction,
-    ) -> DocumentPreludeMatchingFunction {
-        <V as Fold>::fold_document_prelude_matching_function(&mut **self, node)
+        node: &mut DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_document_prelude_matching_functions(
+    fn visit_mut_document_prelude_matching_functions(
         &mut self,
-        node: Vec<DocumentPreludeMatchingFunction>,
-    ) -> Vec<DocumentPreludeMatchingFunction> {
-        <V as Fold>::fold_document_prelude_matching_functions(&mut **self, node)
+        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
-        <V as Fold>::fold_extension_name(&mut **self, node)
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_extension_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
-        <V as Fold>::fold_family_name(&mut **self, node)
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_family_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
-        <V as Fold>::fold_family_names(&mut **self, node)
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_family_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex) -> Flex {
-        <V as Fold>::fold_flex(&mut **self, node)
+    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_flex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_font_feature_values_prelude(
+    fn visit_mut_font_feature_values_prelude(
         &mut self,
-        node: FontFeatureValuesPrelude,
-    ) -> FontFeatureValuesPrelude {
-        <V as Fold>::fold_font_feature_values_prelude(&mut **self, node)
+        node: &mut FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_complex_selector(
+    fn visit_mut_forgiving_complex_selector(
         &mut self,
-        node: ForgivingComplexSelector,
-    ) -> ForgivingComplexSelector {
-        <V as Fold>::fold_forgiving_complex_selector(&mut **self, node)
+        node: &mut ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_complex_selectors(
+    fn visit_mut_forgiving_complex_selectors(
         &mut self,
-        node: Vec<ForgivingComplexSelector>,
-    ) -> Vec<ForgivingComplexSelector> {
-        <V as Fold>::fold_forgiving_complex_selectors(&mut **self, node)
+        node: &mut Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector(
+    fn visit_mut_forgiving_relative_selector(
         &mut self,
-        node: ForgivingRelativeSelector,
-    ) -> ForgivingRelativeSelector {
-        <V as Fold>::fold_forgiving_relative_selector(&mut **self, node)
+        node: &mut ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector_list(
+    fn visit_mut_forgiving_relative_selector_list(
         &mut self,
-        node: ForgivingRelativeSelectorList,
-    ) -> ForgivingRelativeSelectorList {
-        <V as Fold>::fold_forgiving_relative_selector_list(&mut **self, node)
+        node: &mut ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_forgiving_relative_selectors(
+    fn visit_mut_forgiving_relative_selectors(
         &mut self,
-        node: Vec<ForgivingRelativeSelector>,
-    ) -> Vec<ForgivingRelativeSelector> {
-        <V as Fold>::fold_forgiving_relative_selectors(&mut **self, node)
+        node: &mut Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_forgiving_selector_list(
+    fn visit_mut_forgiving_selector_list(
         &mut self,
-        node: ForgivingSelectorList,
-    ) -> ForgivingSelectorList {
-        <V as Fold>::fold_forgiving_selector_list(&mut **self, node)
+        node: &mut ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
-        <V as Fold>::fold_frequency(&mut **self, node)
+    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_frequency(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
-        <V as Fold>::fold_frequency_percentage(&mut **self, node)
+    fn visit_mut_frequency_percentage(
+        &mut self,
+        node: &mut FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_frequency_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
-        <V as Fold>::fold_function(&mut **self, node)
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
-        <V as Fold>::fold_function_name(&mut **self, node)
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
-        <V as Fold>::fold_general_enclosed(&mut **self, node)
+    fn visit_mut_general_enclosed(
+        &mut self,
+        node: &mut GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_general_enclosed(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
-        <V as Fold>::fold_hex_color(&mut **self, node)
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_hex_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue) -> Hue {
-        <V as Fold>::fold_hue(&mut **self, node)
+    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_hue(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
-        <V as Fold>::fold_id_selector(&mut **self, node)
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_id_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
-        <V as Fold>::fold_ident(&mut **self, node)
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
-        <V as Fold>::fold_idents(&mut **self, node)
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
-        <V as Fold>::fold_import_conditions(&mut **self, node)
+    fn visit_mut_import_conditions(
+        &mut self,
+        node: &mut ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
-        <V as Fold>::fold_import_href(&mut **self, node)
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_href(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
-        <V as Fold>::fold_import_layer_name(&mut **self, node)
+    fn visit_mut_import_layer_name(
+        &mut self,
+        node: &mut ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
-        <V as Fold>::fold_import_prelude(&mut **self, node)
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
-        <V as Fold>::fold_important_flag(&mut **self, node)
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer) -> Integer {
-        <V as Fold>::fold_integer(&mut **self, node)
+    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_integer(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
-        <V as Fold>::fold_keyframe_block(&mut **self, node)
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
-        <V as Fold>::fold_keyframe_selector(&mut **self, node)
+    fn visit_mut_keyframe_selector(
+        &mut self,
+        node: &mut KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
-        <V as Fold>::fold_keyframe_selectors(&mut **self, node)
+    fn visit_mut_keyframe_selectors(
+        &mut self,
+        node: &mut Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
-        <V as Fold>::fold_keyframes_name(&mut **self, node)
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_function(
+    fn visit_mut_keyframes_pseudo_function(
         &mut self,
-        node: KeyframesPseudoFunction,
-    ) -> KeyframesPseudoFunction {
-        <V as Fold>::fold_keyframes_pseudo_function(&mut **self, node)
+        node: &mut KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_prefix(
+    fn visit_mut_keyframes_pseudo_prefix(
         &mut self,
-        node: KeyframesPseudoPrefix,
-    ) -> KeyframesPseudoPrefix {
-        <V as Fold>::fold_keyframes_pseudo_prefix(&mut **self, node)
+        node: &mut KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
-        <V as Fold>::fold_layer_name(&mut **self, node)
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
-        <V as Fold>::fold_layer_name_list(&mut **self, node)
+    fn visit_mut_layer_name_list(
+        &mut self,
+        node: &mut LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_layer_name_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
-        <V as Fold>::fold_layer_names(&mut **self, node)
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
-        <V as Fold>::fold_layer_prelude(&mut **self, node)
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length) -> Length {
-        <V as Fold>::fold_length(&mut **self, node)
+    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_length(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
-        <V as Fold>::fold_length_percentage(&mut **self, node)
+    fn visit_mut_length_percentage(
+        &mut self,
+        node: &mut LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_length_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_list_of_component_values(
+    fn visit_mut_list_of_component_values(
         &mut self,
-        node: ListOfComponentValues,
-    ) -> ListOfComponentValues {
-        <V as Fold>::fold_list_of_component_values(&mut **self, node)
+        node: &mut ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_list_of_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
-        <V as Fold>::fold_media_and(&mut **self, node)
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
-        <V as Fold>::fold_media_condition(&mut **self, node)
+    fn visit_mut_media_condition(
+        &mut self,
+        node: &mut MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_all_type(
+    fn visit_mut_media_condition_all_type(
         &mut self,
-        node: MediaConditionAllType,
-    ) -> MediaConditionAllType {
-        <V as Fold>::fold_media_condition_all_type(&mut **self, node)
+        node: &mut MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_all_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_all_types(
+    fn visit_mut_media_condition_all_types(
         &mut self,
-        node: Vec<MediaConditionAllType>,
-    ) -> Vec<MediaConditionAllType> {
-        <V as Fold>::fold_media_condition_all_types(&mut **self, node)
+        node: &mut Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_all_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
-        <V as Fold>::fold_media_condition_type(&mut **self, node)
+    fn visit_mut_media_condition_type(
+        &mut self,
+        node: &mut MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_without_or(
+    fn visit_mut_media_condition_without_or(
         &mut self,
-        node: MediaConditionWithoutOr,
-    ) -> MediaConditionWithoutOr {
-        <V as Fold>::fold_media_condition_without_or(&mut **self, node)
+        node: &mut MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_condition_without_or_type(
+    fn visit_mut_media_condition_without_or_type(
         &mut self,
-        node: MediaConditionWithoutOrType,
-    ) -> MediaConditionWithoutOrType {
-        <V as Fold>::fold_media_condition_without_or_type(&mut **self, node)
+        node: &mut MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_condition_without_or_types(
+    fn visit_mut_media_condition_without_or_types(
         &mut self,
-        node: Vec<MediaConditionWithoutOrType>,
-    ) -> Vec<MediaConditionWithoutOrType> {
-        <V as Fold>::fold_media_condition_without_or_types(&mut **self, node)
+        node: &mut Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
-        <V as Fold>::fold_media_feature(&mut **self, node)
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
-        <V as Fold>::fold_media_feature_boolean(&mut **self, node)
+    fn visit_mut_media_feature_boolean(
+        &mut self,
+        node: &mut MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
-        <V as Fold>::fold_media_feature_name(&mut **self, node)
+    fn visit_mut_media_feature_name(
+        &mut self,
+        node: &mut MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
-        <V as Fold>::fold_media_feature_plain(&mut **self, node)
+    fn visit_mut_media_feature_plain(
+        &mut self,
+        node: &mut MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
-        <V as Fold>::fold_media_feature_range(&mut **self, node)
+    fn visit_mut_media_feature_range(
+        &mut self,
+        node: &mut MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_feature_range_comparison(
+    fn visit_mut_media_feature_range_comparison(
         &mut self,
-        node: MediaFeatureRangeComparison,
-    ) -> MediaFeatureRangeComparison {
-        <V as Fold>::fold_media_feature_range_comparison(&mut **self, node)
+        node: &mut MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_feature_range_interval(
+    fn visit_mut_media_feature_range_interval(
         &mut self,
-        node: MediaFeatureRangeInterval,
-    ) -> MediaFeatureRangeInterval {
-        <V as Fold>::fold_media_feature_range_interval(&mut **self, node)
+        node: &mut MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
-        <V as Fold>::fold_media_feature_value(&mut **self, node)
+    fn visit_mut_media_feature_value(
+        &mut self,
+        node: &mut MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
-        <V as Fold>::fold_media_in_parens(&mut **self, node)
+    fn visit_mut_media_in_parens(
+        &mut self,
+        node: &mut MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
-        <V as Fold>::fold_media_not(&mut **self, node)
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
-        <V as Fold>::fold_media_or(&mut **self, node)
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
-        <V as Fold>::fold_media_query(&mut **self, node)
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
-        <V as Fold>::fold_media_query_list(&mut **self, node)
+    fn visit_mut_media_query_list(
+        &mut self,
+        node: &mut MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
-        <V as Fold>::fold_media_querys(&mut **self, node)
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_querys(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
-        <V as Fold>::fold_media_type(&mut **self, node)
+    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
-        <V as Fold>::fold_named_namespace(&mut **self, node)
+    fn visit_mut_named_namespace(
+        &mut self,
+        node: &mut NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_named_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
-        <V as Fold>::fold_namespace(&mut **self, node)
+    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
-        <V as Fold>::fold_namespace_prefix(&mut **self, node)
+    fn visit_mut_namespace_prefix(
+        &mut self,
+        node: &mut NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
-        <V as Fold>::fold_namespace_prelude(&mut **self, node)
+    fn visit_mut_namespace_prelude(
+        &mut self,
+        node: &mut NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
-        <V as Fold>::fold_namespace_prelude_uri(&mut **self, node)
+    fn visit_mut_namespace_prelude_uri(
+        &mut self,
+        node: &mut NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
-        <V as Fold>::fold_nesting_selector(&mut **self, node)
+    fn visit_mut_nesting_selector(
+        &mut self,
+        node: &mut NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
-        <V as Fold>::fold_number(&mut **self, node)
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
-        <V as Fold>::fold_number_type(&mut **self, node)
+    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_at_rule_prelude(
+    fn visit_mut_opt_at_rule_prelude(
         &mut self,
-        node: Option<Box<AtRulePrelude>>,
-    ) -> Option<Box<AtRulePrelude>> {
-        <V as Fold>::fold_opt_at_rule_prelude(&mut **self, node)
+        node: &mut Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
-        <V as Fold>::fold_opt_atom(&mut **self, node)
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_matcher(
+    fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
-        node: Option<AttributeSelectorMatcher>,
-    ) -> Option<AttributeSelectorMatcher> {
-        <V as Fold>::fold_opt_attribute_selector_matcher(&mut **self, node)
+        node: &mut Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_modifier(
+    fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
-        node: Option<AttributeSelectorModifier>,
-    ) -> Option<AttributeSelectorModifier> {
-        <V as Fold>::fold_opt_attribute_selector_modifier(&mut **self, node)
+        node: &mut Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_value(
+    fn visit_mut_opt_attribute_selector_value(
         &mut self,
-        node: Option<AttributeSelectorValue>,
-    ) -> Option<AttributeSelectorValue> {
-        <V as Fold>::fold_opt_attribute_selector_value(&mut **self, node)
+        node: &mut Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
-        <V as Fold>::fold_opt_combinator(&mut **self, node)
+    fn visit_mut_opt_combinator(
+        &mut self,
+        node: &mut Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
-        <V as Fold>::fold_opt_container_name(&mut **self, node)
+    fn visit_mut_opt_container_name(
+        &mut self,
+        node: &mut Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_forgiving_selector_list(
+    fn visit_mut_opt_forgiving_selector_list(
         &mut self,
-        node: Option<ForgivingSelectorList>,
-    ) -> Option<ForgivingSelectorList> {
-        <V as Fold>::fold_opt_forgiving_selector_list(&mut **self, node)
+        node: &mut Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
-        <V as Fold>::fold_opt_function(&mut **self, node)
+    fn visit_mut_opt_function(
+        &mut self,
+        node: &mut Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
-        <V as Fold>::fold_opt_ident(&mut **self, node)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_import_conditions(
+    fn visit_mut_opt_import_conditions(
         &mut self,
-        node: Option<Box<ImportConditions>>,
-    ) -> Option<Box<ImportConditions>> {
-        <V as Fold>::fold_opt_import_conditions(&mut **self, node)
+        node: &mut Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_import_layer_name(
+    fn visit_mut_opt_import_layer_name(
         &mut self,
-        node: Option<Box<ImportLayerName>>,
-    ) -> Option<Box<ImportLayerName>> {
-        <V as Fold>::fold_opt_import_layer_name(&mut **self, node)
+        node: &mut Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
-        <V as Fold>::fold_opt_important_flag(&mut **self, node)
+    fn visit_mut_opt_important_flag(
+        &mut self,
+        node: &mut Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_media_condition_type(
+    fn visit_mut_opt_media_condition_type(
         &mut self,
-        node: Option<Box<MediaConditionType>>,
-    ) -> Option<Box<MediaConditionType>> {
-        <V as Fold>::fold_opt_media_condition_type(&mut **self, node)
+        node: &mut Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_media_query_list(
+    fn visit_mut_opt_media_query_list(
         &mut self,
-        node: Option<Box<MediaQueryList>>,
-    ) -> Option<Box<MediaQueryList>> {
-        <V as Fold>::fold_opt_media_query_list(&mut **self, node)
+        node: &mut Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
-        <V as Fold>::fold_opt_media_type(&mut **self, node)
+    fn visit_mut_opt_media_type(
+        &mut self,
+        node: &mut Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
-        <V as Fold>::fold_opt_namespace(&mut **self, node)
+    fn visit_mut_opt_namespace(
+        &mut self,
+        node: &mut Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_namespace_prefix(
+    fn visit_mut_opt_namespace_prefix(
         &mut self,
-        node: Option<NamespacePrefix>,
-    ) -> Option<NamespacePrefix> {
-        <V as Fold>::fold_opt_namespace_prefix(&mut **self, node)
+        node: &mut Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_nesting_selector(
+    fn visit_mut_opt_nesting_selector(
         &mut self,
-        node: Option<NestingSelector>,
-    ) -> Option<NestingSelector> {
-        <V as Fold>::fold_opt_nesting_selector(&mut **self, node)
+        node: &mut Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
-        <V as Fold>::fold_opt_number(&mut **self, node)
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_page_selector_pseudos(
+    fn visit_mut_opt_page_selector_pseudos(
         &mut self,
-        node: Option<Vec<PageSelectorPseudo>>,
-    ) -> Option<Vec<PageSelectorPseudo>> {
-        <V as Fold>::fold_opt_page_selector_pseudos(&mut **self, node)
+        node: &mut Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_page_selector_type(
+    fn visit_mut_opt_page_selector_type(
         &mut self,
-        node: Option<PageSelectorType>,
-    ) -> Option<PageSelectorType> {
-        <V as Fold>::fold_opt_page_selector_type(&mut **self, node)
+        node: &mut Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_pseudo_class_selector_childrens(
+    fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoClassSelectorChildren>>,
-    ) -> Option<Vec<PseudoClassSelectorChildren>> {
-        <V as Fold>::fold_opt_pseudo_class_selector_childrens(&mut **self, node)
+        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_pseudo_element_selector_childrens(
+    fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoElementSelectorChildren>>,
-    ) -> Option<Vec<PseudoElementSelectorChildren>> {
-        <V as Fold>::fold_opt_pseudo_element_selector_childrens(&mut **self, node)
+        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
-        <V as Fold>::fold_opt_simple_block(&mut **self, node)
+    fn visit_mut_opt_simple_block(
+        &mut self,
+        node: &mut Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_type_selector(
+    fn visit_mut_opt_type_selector(
         &mut self,
-        node: Option<Box<TypeSelector>>,
-    ) -> Option<Box<TypeSelector>> {
-        <V as Fold>::fold_opt_type_selector(&mut **self, node)
+        node: &mut Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_url_modifiers(
+    fn visit_mut_opt_url_modifiers(
         &mut self,
-        node: Option<Vec<UrlModifier>>,
-    ) -> Option<Vec<UrlModifier>> {
-        <V as Fold>::fold_opt_url_modifiers(&mut **self, node)
+        node: &mut Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
-        <V as Fold>::fold_opt_url_value(&mut **self, node)
+    fn visit_mut_opt_url_value(
+        &mut self,
+        node: &mut Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
-        <V as Fold>::fold_page_selector(&mut **self, node)
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
-        <V as Fold>::fold_page_selector_list(&mut **self, node)
+    fn visit_mut_page_selector_list(
+        &mut self,
+        node: &mut PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
-        <V as Fold>::fold_page_selector_pseudo(&mut **self, node)
+    fn visit_mut_page_selector_pseudo(
+        &mut self,
+        node: &mut PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_pseudos(
+    fn visit_mut_page_selector_pseudos(
         &mut self,
-        node: Vec<PageSelectorPseudo>,
-    ) -> Vec<PageSelectorPseudo> {
-        <V as Fold>::fold_page_selector_pseudos(&mut **self, node)
+        node: &mut Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
-        <V as Fold>::fold_page_selector_type(&mut **self, node)
+    fn visit_mut_page_selector_type(
+        &mut self,
+        node: &mut PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
-        <V as Fold>::fold_page_selectors(&mut **self, node)
+    fn visit_mut_page_selectors(
+        &mut self,
+        node: &mut Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_page_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
-        <V as Fold>::fold_percentage(&mut **self, node)
+    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
-        <V as Fold>::fold_pseudo_class_selector(&mut **self, node)
+    fn visit_mut_pseudo_class_selector(
+        &mut self,
+        node: &mut PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_children(
+    fn visit_mut_pseudo_class_selector_children(
         &mut self,
-        node: PseudoClassSelectorChildren,
-    ) -> PseudoClassSelectorChildren {
-        <V as Fold>::fold_pseudo_class_selector_children(&mut **self, node)
+        node: &mut PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_childrens(
+    fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
-        node: Vec<PseudoClassSelectorChildren>,
-    ) -> Vec<PseudoClassSelectorChildren> {
-        <V as Fold>::fold_pseudo_class_selector_childrens(&mut **self, node)
+        node: &mut Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_pseudo_element_selector(
+    fn visit_mut_pseudo_element_selector(
         &mut self,
-        node: PseudoElementSelector,
-    ) -> PseudoElementSelector {
-        <V as Fold>::fold_pseudo_element_selector(&mut **self, node)
+        node: &mut PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_children(
+    fn visit_mut_pseudo_element_selector_children(
         &mut self,
-        node: PseudoElementSelectorChildren,
-    ) -> PseudoElementSelectorChildren {
-        <V as Fold>::fold_pseudo_element_selector_children(&mut **self, node)
+        node: &mut PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_childrens(
+    fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
-        node: Vec<PseudoElementSelectorChildren>,
-    ) -> Vec<PseudoElementSelectorChildren> {
-        <V as Fold>::fold_pseudo_element_selector_childrens(&mut **self, node)
+        node: &mut Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
-        <V as Fold>::fold_qualified_rule(&mut **self, node)
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_qualified_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
-        <V as Fold>::fold_qualified_rule_prelude(&mut **self, node)
+    fn visit_mut_qualified_rule_prelude(
+        &mut self,
+        node: &mut QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
-        <V as Fold>::fold_query_in_parens(&mut **self, node)
+    fn visit_mut_query_in_parens(
+        &mut self,
+        node: &mut QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_query_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
-        <V as Fold>::fold_ratio(&mut **self, node)
+    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ratio(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
-        <V as Fold>::fold_relative_selector(&mut **self, node)
+    fn visit_mut_relative_selector(
+        &mut self,
+        node: &mut RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
-        <V as Fold>::fold_relative_selector_list(&mut **self, node)
+    fn visit_mut_relative_selector_list(
+        &mut self,
+        node: &mut RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
-        <V as Fold>::fold_relative_selectors(&mut **self, node)
+    fn visit_mut_relative_selectors(
+        &mut self,
+        node: &mut Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
-        <V as Fold>::fold_resolution(&mut **self, node)
+    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_resolution(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule) -> Rule {
-        <V as Fold>::fold_rule(&mut **self, node)
+    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
-        <V as Fold>::fold_rules(&mut **self, node)
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rules(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
-        <V as Fold>::fold_scope_range(&mut **self, node)
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_scope_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
-        <V as Fold>::fold_selector_list(&mut **self, node)
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_sequence_of_custom_idents(
+    fn visit_mut_sequence_of_custom_idents(
         &mut self,
-        node: SequenceOfCustomIdents,
-    ) -> SequenceOfCustomIdents {
-        <V as Fold>::fold_sequence_of_custom_idents(&mut **self, node)
+        node: &mut SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
-        <V as Fold>::fold_simple_block(&mut **self, node)
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
-        <V as Fold>::fold_size_feature(&mut **self, node)
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
-        <V as Fold>::fold_size_feature_boolean(&mut **self, node)
+    fn visit_mut_size_feature_boolean(
+        &mut self,
+        node: &mut SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
-        <V as Fold>::fold_size_feature_name(&mut **self, node)
+    fn visit_mut_size_feature_name(
+        &mut self,
+        node: &mut SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
-        <V as Fold>::fold_size_feature_plain(&mut **self, node)
+    fn visit_mut_size_feature_plain(
+        &mut self,
+        node: &mut SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
-        <V as Fold>::fold_size_feature_range(&mut **self, node)
+    fn visit_mut_size_feature_range(
+        &mut self,
+        node: &mut SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_range_comparison(
+    fn visit_mut_size_feature_range_comparison(
         &mut self,
-        node: SizeFeatureRangeComparison,
-    ) -> SizeFeatureRangeComparison {
-        <V as Fold>::fold_size_feature_range_comparison(&mut **self, node)
+        node: &mut SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_size_feature_range_interval(
+    fn visit_mut_size_feature_range_interval(
         &mut self,
-        node: SizeFeatureRangeInterval,
-    ) -> SizeFeatureRangeInterval {
-        <V as Fold>::fold_size_feature_range_interval(&mut **self, node)
+        node: &mut SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
-        <V as Fold>::fold_size_feature_value(&mut **self, node)
+    fn visit_mut_size_feature_value(
+        &mut self,
+        node: &mut SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
-        <V as Fold>::fold_span(&mut **self, node)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
-        <V as Fold>::fold_str(&mut **self, node)
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
-        <V as Fold>::fold_style_block(&mut **self, node)
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_style_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
-        <V as Fold>::fold_stylesheet(&mut **self, node)
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stylesheet(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
-        <V as Fold>::fold_subclass_selector(&mut **self, node)
+    fn visit_mut_subclass_selector(
+        &mut self,
+        node: &mut SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_subclass_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
-        <V as Fold>::fold_subclass_selectors(&mut **self, node)
+    fn visit_mut_subclass_selectors(
+        &mut self,
+        node: &mut Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_subclass_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
-        <V as Fold>::fold_supports_and(&mut **self, node)
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
-        <V as Fold>::fold_supports_condition(&mut **self, node)
+    fn visit_mut_supports_condition(
+        &mut self,
+        node: &mut SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_condition_type(
+    fn visit_mut_supports_condition_type(
         &mut self,
-        node: SupportsConditionType,
-    ) -> SupportsConditionType {
-        <V as Fold>::fold_supports_condition_type(&mut **self, node)
+        node: &mut SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_condition_types(
+    fn visit_mut_supports_condition_types(
         &mut self,
-        node: Vec<SupportsConditionType>,
-    ) -> Vec<SupportsConditionType> {
-        <V as Fold>::fold_supports_condition_types(&mut **self, node)
+        node: &mut Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
-        <V as Fold>::fold_supports_feature(&mut **self, node)
+    fn visit_mut_supports_feature(
+        &mut self,
+        node: &mut SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
-        <V as Fold>::fold_supports_in_parens(&mut **self, node)
+    fn visit_mut_supports_in_parens(
+        &mut self,
+        node: &mut SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_supports_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
-        <V as Fold>::fold_supports_not(&mut **self, node)
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
-        <V as Fold>::fold_supports_or(&mut **self, node)
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
-        <V as Fold>::fold_tag_name_selector(&mut **self, node)
+    fn visit_mut_tag_name_selector(
+        &mut self,
+        node: &mut TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_tag_name_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time) -> Time {
-        <V as Fold>::fold_time(&mut **self, node)
+    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_time(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
-        <V as Fold>::fold_time_percentage(&mut **self, node)
+    fn visit_mut_time_percentage(
+        &mut self,
+        node: &mut TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_time_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token) -> Token {
-        <V as Fold>::fold_token(&mut **self, node)
+    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
-        <V as Fold>::fold_token_and_span(&mut **self, node)
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_token_and_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
-        <V as Fold>::fold_type_selector(&mut **self, node)
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
-        <V as Fold>::fold_unicode_range(&mut **self, node)
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unicode_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
-        <V as Fold>::fold_universal_selector(&mut **self, node)
+    fn visit_mut_universal_selector(
+        &mut self,
+        node: &mut UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_universal_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
-        <V as Fold>::fold_unknown_dimension(&mut **self, node)
+    fn visit_mut_unknown_dimension(
+        &mut self,
+        node: &mut UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_unknown_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url) -> Url {
-        <V as Fold>::fold_url(&mut **self, node)
+    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
-        <V as Fold>::fold_url_key_value(&mut **self, node)
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_key_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
-        <V as Fold>::fold_url_modifier(&mut **self, node)
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
-        <V as Fold>::fold_url_modifiers(&mut **self, node)
+    fn visit_mut_url_modifiers(
+        &mut self,
+        node: &mut Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
-        <V as Fold>::fold_url_value(&mut **self, node)
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
-        <V as Fold>::fold_url_value_raw(&mut **self, node)
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_value_raw(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName) -> WqName {
-        <V as Fold>::fold_wq_name(&mut **self, node)
+    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_wq_name(&mut **self, node, __ast_path)
     }
 }
-impl<A, B> Fold for ::swc_visit::Either<A, B>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<A, B> VisitMutAstPath for ::swc_visit::Either<A, B>
 where
-    A: Fold,
-    B: Fold,
+    A: VisitMutAstPath,
+    B: VisitMutAstPath,
 {
     #[inline]
-    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
+    fn visit_mut_absolute_color_base(
+        &mut self,
+        node: &mut AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_absolute_color_base(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_absolute_color_base(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_absolute_color_base(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_absolute_color_base(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_alpha_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_alpha_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_alpha_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_alpha_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_an_plus_b(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_an_plus_b(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_an_plus_b(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_an_plus_b(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
+    fn visit_mut_an_plus_b_notation(
+        &mut self,
+        node: &mut AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_an_plus_b_notation(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_an_plus_b_notation(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_an_plus_b_notation(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_an_plus_b_notation(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle) -> Angle {
+    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_angle(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_angle(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_angle(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_angle(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
+    fn visit_mut_angle_percentage(
+        &mut self,
+        node: &mut AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_angle_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_angle_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_angle_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_angle_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_any_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_any_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_any_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_any_namespace(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_at_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_at_rule(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_at_rule(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_at_rule(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_at_rule_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_at_rule_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_at_rule_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_at_rule_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
+    fn visit_mut_at_rule_prelude(
+        &mut self,
+        node: &mut AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_at_rule_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_at_rule_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_at_rule_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_at_rule_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
+    fn visit_mut_attribute_selector(
+        &mut self,
+        node: &mut AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_attribute_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_attribute_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_attribute_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_attribute_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher(
+    fn visit_mut_attribute_selector_matcher(
         &mut self,
-        node: AttributeSelectorMatcher,
-    ) -> AttributeSelectorMatcher {
+        node: &mut AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_attribute_selector_matcher(visitor, node)
+                VisitMutAstPath::visit_mut_attribute_selector_matcher(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_attribute_selector_matcher(visitor, node)
+                VisitMutAstPath::visit_mut_attribute_selector_matcher(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher_value(
+    fn visit_mut_attribute_selector_matcher_value(
         &mut self,
-        node: AttributeSelectorMatcherValue,
-    ) -> AttributeSelectorMatcherValue {
+        node: &mut AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_attribute_selector_matcher_value(visitor, node)
+                VisitMutAstPath::visit_mut_attribute_selector_matcher_value(
+                    visitor, node, __ast_path,
+                )
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_attribute_selector_matcher_value(visitor, node)
+                VisitMutAstPath::visit_mut_attribute_selector_matcher_value(
+                    visitor, node, __ast_path,
+                )
             }
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_modifier(
+    fn visit_mut_attribute_selector_modifier(
         &mut self,
-        node: AttributeSelectorModifier,
-    ) -> AttributeSelectorModifier {
+        node: &mut AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_attribute_selector_modifier(visitor, node)
+                VisitMutAstPath::visit_mut_attribute_selector_modifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_attribute_selector_modifier(visitor, node)
+                VisitMutAstPath::visit_mut_attribute_selector_modifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_value(
+    fn visit_mut_attribute_selector_value(
         &mut self,
-        node: AttributeSelectorValue,
-    ) -> AttributeSelectorValue {
+        node: &mut AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_attribute_selector_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_attribute_selector_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_attribute_selector_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_attribute_selector_value(visitor, node, __ast_path)
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_bin_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_bin_op(visitor, node, __ast_path)
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_operator(visitor, node, __ast_path)
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_mut_calc_operator_type(
+        &mut self,
+        node: &mut CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_operator_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_operator_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_bin_op(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_bin_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_product(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_product(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
+    fn visit_mut_calc_product_or_operator(
+        &mut self,
+        node: &mut CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_operator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_operator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_product_or_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_product_or_operator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
+    fn visit_mut_calc_product_or_operators(
+        &mut self,
+        node: &mut Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_operator_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_operator_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_product_or_operators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_product_or_operators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_product(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_product(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_sum(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_sum(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_product_or_operator(
-        &mut self,
-        node: CalcProductOrOperator,
-    ) -> CalcProductOrOperator {
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_product_or_operator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_product_or_operator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_product_or_operators(
+    fn visit_mut_calc_value_or_operator(
         &mut self,
-        node: Vec<CalcProductOrOperator>,
-    ) -> Vec<CalcProductOrOperator> {
+        node: &mut CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_product_or_operators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_value_or_operator(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_calc_product_or_operators(visitor, node)
+                VisitMutAstPath::visit_mut_calc_value_or_operator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
+    fn visit_mut_calc_value_or_operators(
+        &mut self,
+        node: &mut Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_sum(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_sum(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_calc_value_or_operators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_calc_value_or_operators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_value_or_operator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_value_or_operator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_cmyk_component(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_cmyk_component(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_calc_value_or_operators(
-        &mut self,
-        node: Vec<CalcValueOrOperator>,
-    ) -> Vec<CalcValueOrOperator> {
+    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_calc_value_or_operators(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_calc_value_or_operators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_color(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_color(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
+    fn visit_mut_color_profile_name(
+        &mut self,
+        node: &mut ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_color_profile_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_color_profile_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
+    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_cmyk_component(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_cmyk_component(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_combinator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_combinator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color) -> Color {
+    fn visit_mut_combinator_value(
+        &mut self,
+        node: &mut CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_color(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_color(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_combinator_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_combinator_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
+    fn visit_mut_complex_selector(
+        &mut self,
+        node: &mut ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_color_profile_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_color_profile_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
+    fn visit_mut_complex_selector_children(
+        &mut self,
+        node: &mut ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_combinator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_combinator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selector_children(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selector_children(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
+    fn visit_mut_complex_selector_childrens(
+        &mut self,
+        node: &mut Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_combinator_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_combinator_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selector_childrens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selector_childrens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
+    fn visit_mut_complex_selectors(
+        &mut self,
+        node: &mut Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_complex_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_complex_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_complex_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_complex_selector_children(
+    fn visit_mut_component_value(
         &mut self,
-        node: ComplexSelectorChildren,
-    ) -> ComplexSelectorChildren {
+        node: &mut ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_complex_selector_children(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_component_value(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_complex_selector_children(visitor, node)
+                VisitMutAstPath::visit_mut_component_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_complex_selector_childrens(
+    fn visit_mut_component_values(
         &mut self,
-        node: Vec<ComplexSelectorChildren>,
-    ) -> Vec<ComplexSelectorChildren> {
+        node: &mut Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_complex_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_component_values(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_complex_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_component_values(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
+    fn visit_mut_compound_selector(
+        &mut self,
+        node: &mut CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_complex_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_complex_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_compound_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_compound_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
+    fn visit_mut_compound_selector_list(
+        &mut self,
+        node: &mut CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_component_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_component_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_compound_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_compound_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
+    fn visit_mut_compound_selectors(
+        &mut self,
+        node: &mut Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_component_values(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_component_values(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_compound_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_compound_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
+    fn visit_mut_container_condition(
+        &mut self,
+        node: &mut ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_compound_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_compound_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_compound_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_compound_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
+    fn visit_mut_container_query(
+        &mut self,
+        node: &mut ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_compound_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_compound_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
+    fn visit_mut_container_query_and(
+        &mut self,
+        node: &mut ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_condition(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_condition(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
+    fn visit_mut_container_query_not(
+        &mut self,
+        node: &mut ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_not(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_not(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
+    fn visit_mut_container_query_or(
+        &mut self,
+        node: &mut ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_query(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
+    fn visit_mut_container_query_type(
+        &mut self,
+        node: &mut ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_query_and(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_query_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
+    fn visit_mut_container_query_types(
+        &mut self,
+        node: &mut Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_query_not(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_query_not(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_container_query_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
+    fn visit_mut_custom_highlight_name(
+        &mut self,
+        node: &mut CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_query_or(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_query_or(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_custom_highlight_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_custom_highlight_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_query_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_query_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_custom_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_custom_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_container_query_types(
+    fn visit_mut_custom_idents(
         &mut self,
-        node: Vec<ContainerQueryType>,
-    ) -> Vec<ContainerQueryType> {
+        node: &mut Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_container_query_types(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_container_query_types(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_custom_idents(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_custom_idents(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
+    fn visit_mut_custom_media_query(
+        &mut self,
+        node: &mut CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_custom_highlight_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_custom_highlight_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_custom_media_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_custom_media_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
+    fn visit_mut_custom_media_query_media_type(
+        &mut self,
+        node: &mut CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_custom_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_custom_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_custom_media_query_media_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_custom_media_query_media_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
+    fn visit_mut_custom_property_name(
+        &mut self,
+        node: &mut CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_custom_idents(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_custom_idents(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_custom_property_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_custom_property_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_custom_media_query(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_custom_media_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_dashed_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_dashed_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_custom_media_query_media_type(
-        &mut self,
-        node: CustomMediaQueryMediaType,
-    ) -> CustomMediaQueryMediaType {
+    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_custom_media_query_media_type(visitor, node)
+                VisitMutAstPath::visit_mut_declaration(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_custom_media_query_media_type(visitor, node)
+                VisitMutAstPath::visit_mut_declaration(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
+    fn visit_mut_declaration_name(
+        &mut self,
+        node: &mut DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_custom_property_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_custom_property_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_declaration_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_declaration_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
+    fn visit_mut_declaration_or_at_rule(
+        &mut self,
+        node: &mut DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_dashed_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_dashed_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_declaration_or_at_rule(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_declaration_or_at_rule(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_declaration(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_declaration(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_delimiter(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_delimiter(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
+    fn visit_mut_delimiter_value(
+        &mut self,
+        node: &mut DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_declaration_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_declaration_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_delimiter_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_delimiter_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
+    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_declaration_or_at_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_declaration_or_at_rule(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_dimension(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_dimension(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
+    fn visit_mut_dimension_token(
+        &mut self,
+        node: &mut DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_delimiter(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_delimiter(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_dimension_token(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_dimension_token(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
+    fn visit_mut_document_prelude(
+        &mut self,
+        node: &mut DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_delimiter_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_delimiter_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_document_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_document_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
+    fn visit_mut_document_prelude_matching_function(
+        &mut self,
+        node: &mut DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_dimension(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_dimension(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_document_prelude_matching_function(
+                    visitor, node, __ast_path,
+                )
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_document_prelude_matching_function(
+                    visitor, node, __ast_path,
+                )
+            }
         }
     }
 
     #[inline]
-    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
+    fn visit_mut_document_prelude_matching_functions(
+        &mut self,
+        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_dimension_token(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_dimension_token(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_document_prelude_matching_functions(
+                    visitor, node, __ast_path,
+                )
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_document_prelude_matching_functions(
+                    visitor, node, __ast_path,
+                )
+            }
         }
     }
 
     #[inline]
-    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_document_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_document_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_extension_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_extension_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_document_prelude_matching_function(
-        &mut self,
-        node: DocumentPreludeMatchingFunction,
-    ) -> DocumentPreludeMatchingFunction {
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_document_prelude_matching_function(visitor, node)
+                VisitMutAstPath::visit_mut_family_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_document_prelude_matching_function(visitor, node)
+                VisitMutAstPath::visit_mut_family_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_document_prelude_matching_functions(
-        &mut self,
-        node: Vec<DocumentPreludeMatchingFunction>,
-    ) -> Vec<DocumentPreludeMatchingFunction> {
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_document_prelude_matching_functions(visitor, node)
+                VisitMutAstPath::visit_mut_family_names(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_document_prelude_matching_functions(visitor, node)
+                VisitMutAstPath::visit_mut_family_names(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
+    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_extension_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_extension_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_flex(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_flex(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
+    fn visit_mut_font_feature_values_prelude(
+        &mut self,
+        node: &mut FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_family_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_family_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_font_feature_values_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_font_feature_values_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
+    fn visit_mut_forgiving_complex_selector(
+        &mut self,
+        node: &mut ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_family_names(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_family_names(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_forgiving_complex_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_forgiving_complex_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex) -> Flex {
+    fn visit_mut_forgiving_complex_selectors(
+        &mut self,
+        node: &mut Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_flex(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_flex(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_forgiving_complex_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_forgiving_complex_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_font_feature_values_prelude(
+    fn visit_mut_forgiving_relative_selector(
         &mut self,
-        node: FontFeatureValuesPrelude,
-    ) -> FontFeatureValuesPrelude {
+        node: &mut ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_font_feature_values_prelude(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_relative_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_font_feature_values_prelude(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_relative_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_forgiving_complex_selector(
+    fn visit_mut_forgiving_relative_selector_list(
         &mut self,
-        node: ForgivingComplexSelector,
-    ) -> ForgivingComplexSelector {
+        node: &mut ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_forgiving_complex_selector(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_relative_selector_list(
+                    visitor, node, __ast_path,
+                )
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_forgiving_complex_selector(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_relative_selector_list(
+                    visitor, node, __ast_path,
+                )
             }
         }
     }
 
     #[inline]
-    fn fold_forgiving_complex_selectors(
+    fn visit_mut_forgiving_relative_selectors(
         &mut self,
-        node: Vec<ForgivingComplexSelector>,
-    ) -> Vec<ForgivingComplexSelector> {
+        node: &mut Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_forgiving_complex_selectors(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_relative_selectors(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_forgiving_complex_selectors(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_relative_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector(
+    fn visit_mut_forgiving_selector_list(
         &mut self,
-        node: ForgivingRelativeSelector,
-    ) -> ForgivingRelativeSelector {
+        node: &mut ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_forgiving_relative_selector(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_forgiving_relative_selector(visitor, node)
+                VisitMutAstPath::visit_mut_forgiving_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector_list(
-        &mut self,
-        node: ForgivingRelativeSelectorList,
-    ) -> ForgivingRelativeSelectorList {
+    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_forgiving_relative_selector_list(visitor, node)
+                VisitMutAstPath::visit_mut_frequency(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_forgiving_relative_selector_list(visitor, node)
+                VisitMutAstPath::visit_mut_frequency(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_forgiving_relative_selectors(
+    fn visit_mut_frequency_percentage(
         &mut self,
-        node: Vec<ForgivingRelativeSelector>,
-    ) -> Vec<ForgivingRelativeSelector> {
+        node: &mut FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_forgiving_relative_selectors(visitor, node)
+                VisitMutAstPath::visit_mut_frequency_percentage(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_forgiving_relative_selectors(visitor, node)
+                VisitMutAstPath::visit_mut_frequency_percentage(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_forgiving_selector_list(
-        &mut self,
-        node: ForgivingSelectorList,
-    ) -> ForgivingSelectorList {
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_forgiving_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_forgiving_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_frequency(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_frequency(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_function_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_function_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
+    fn visit_mut_general_enclosed(
+        &mut self,
+        node: &mut GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_frequency_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_frequency_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_general_enclosed(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_general_enclosed(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_function(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_hex_color(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_hex_color(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
+    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_function_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_function_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_hue(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_hue(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_general_enclosed(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_general_enclosed(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_id_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_id_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_hex_color(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_hex_color(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue) -> Hue {
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_hue(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_hue(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_idents(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_idents(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
+    fn visit_mut_import_conditions(
+        &mut self,
+        node: &mut ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_id_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_id_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_conditions(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_conditions(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_href(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_href(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
+    fn visit_mut_import_layer_name(
+        &mut self,
+        node: &mut ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_idents(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_idents(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_layer_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_layer_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_conditions(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_conditions(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_href(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_href(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_important_flag(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_important_flag(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
+    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_layer_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_layer_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_integer(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_integer(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_keyframe_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_keyframe_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
+    fn visit_mut_keyframe_selector(
+        &mut self,
+        node: &mut KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_important_flag(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_important_flag(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_keyframe_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_keyframe_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer) -> Integer {
+    fn visit_mut_keyframe_selectors(
+        &mut self,
+        node: &mut Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_integer(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_integer(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_keyframe_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_keyframe_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_keyframe_block(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_keyframe_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_keyframes_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_keyframes_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
+    fn visit_mut_keyframes_pseudo_function(
+        &mut self,
+        node: &mut KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_keyframe_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_keyframe_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_keyframes_pseudo_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_keyframes_pseudo_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
+    fn visit_mut_keyframes_pseudo_prefix(
+        &mut self,
+        node: &mut KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_keyframe_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_keyframe_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_keyframes_pseudo_prefix(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_keyframes_pseudo_prefix(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_keyframes_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_keyframes_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_layer_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_layer_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_function(
+    fn visit_mut_layer_name_list(
         &mut self,
-        node: KeyframesPseudoFunction,
-    ) -> KeyframesPseudoFunction {
+        node: &mut LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_keyframes_pseudo_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_layer_name_list(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_keyframes_pseudo_function(visitor, node)
+                VisitMutAstPath::visit_mut_layer_name_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_prefix(
-        &mut self,
-        node: KeyframesPseudoPrefix,
-    ) -> KeyframesPseudoPrefix {
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_keyframes_pseudo_prefix(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_keyframes_pseudo_prefix(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_layer_names(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_layer_names(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_layer_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_layer_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_layer_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_layer_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
+    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_layer_name_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_layer_name_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_length(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_length(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
+    fn visit_mut_length_percentage(
+        &mut self,
+        node: &mut LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_layer_names(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_layer_names(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_length_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_length_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
+    fn visit_mut_list_of_component_values(
+        &mut self,
+        node: &mut ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_layer_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_layer_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_list_of_component_values(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_list_of_component_values(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length) -> Length {
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_length(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_length(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
+    fn visit_mut_media_condition(
+        &mut self,
+        node: &mut MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_length_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_length_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_list_of_component_values(
+    fn visit_mut_media_condition_all_type(
         &mut self,
-        node: ListOfComponentValues,
-    ) -> ListOfComponentValues {
+        node: &mut MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_list_of_component_values(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_list_of_component_values(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_all_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_all_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
+    fn visit_mut_media_condition_all_types(
+        &mut self,
+        node: &mut Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_and(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_all_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_all_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
+    fn visit_mut_media_condition_type(
+        &mut self,
+        node: &mut MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_condition(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_condition(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_condition_all_type(
+    fn visit_mut_media_condition_without_or(
         &mut self,
-        node: MediaConditionAllType,
-    ) -> MediaConditionAllType {
+        node: &mut MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_condition_all_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_condition_all_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_without_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_without_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_condition_all_types(
+    fn visit_mut_media_condition_without_or_type(
         &mut self,
-        node: Vec<MediaConditionAllType>,
-    ) -> Vec<MediaConditionAllType> {
+        node: &mut MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_condition_all_types(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_without_or_type(
+                    visitor, node, __ast_path,
+                )
+            }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_media_condition_all_types(visitor, node)
+                VisitMutAstPath::visit_mut_media_condition_without_or_type(
+                    visitor, node, __ast_path,
+                )
             }
         }
     }
 
     #[inline]
-    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
+    fn visit_mut_media_condition_without_or_types(
+        &mut self,
+        node: &mut Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_condition_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_condition_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_without_or_types(
+                    visitor, node, __ast_path,
+                )
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_condition_without_or_types(
+                    visitor, node, __ast_path,
+                )
+            }
         }
     }
 
     #[inline]
-    fn fold_media_condition_without_or(
-        &mut self,
-        node: MediaConditionWithoutOr,
-    ) -> MediaConditionWithoutOr {
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_media_condition_without_or(visitor, node)
+                VisitMutAstPath::visit_mut_media_feature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_media_condition_without_or(visitor, node)
+                VisitMutAstPath::visit_mut_media_feature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_media_condition_without_or_type(
+    fn visit_mut_media_feature_boolean(
         &mut self,
-        node: MediaConditionWithoutOrType,
-    ) -> MediaConditionWithoutOrType {
+        node: &mut MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_media_condition_without_or_type(visitor, node)
+                VisitMutAstPath::visit_mut_media_feature_boolean(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_media_condition_without_or_type(visitor, node)
+                VisitMutAstPath::visit_mut_media_feature_boolean(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_media_condition_without_or_types(
+    fn visit_mut_media_feature_name(
         &mut self,
-        node: Vec<MediaConditionWithoutOrType>,
-    ) -> Vec<MediaConditionWithoutOrType> {
+        node: &mut MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_media_condition_without_or_types(visitor, node)
+                VisitMutAstPath::visit_mut_media_feature_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_media_condition_without_or_types(visitor, node)
+                VisitMutAstPath::visit_mut_media_feature_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
+    fn visit_mut_media_feature_plain(
+        &mut self,
+        node: &mut MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_plain(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_plain(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
+    fn visit_mut_media_feature_range(
+        &mut self,
+        node: &mut MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_boolean(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_boolean(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
+    fn visit_mut_media_feature_range_comparison(
+        &mut self,
+        node: &mut MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_range_comparison(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_range_comparison(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
+    fn visit_mut_media_feature_range_interval(
+        &mut self,
+        node: &mut MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_plain(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_plain(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_range_interval(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_range_interval(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
+    fn visit_mut_media_feature_value(
+        &mut self,
+        node: &mut MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_range(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_feature_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_feature_range_comparison(
+    fn visit_mut_media_in_parens(
         &mut self,
-        node: MediaFeatureRangeComparison,
-    ) -> MediaFeatureRangeComparison {
+        node: &mut MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_media_feature_range_comparison(visitor, node)
+                VisitMutAstPath::visit_mut_media_in_parens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_media_feature_range_comparison(visitor, node)
+                VisitMutAstPath::visit_mut_media_in_parens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_media_feature_range_interval(
-        &mut self,
-        node: MediaFeatureRangeInterval,
-    ) -> MediaFeatureRangeInterval {
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_media_feature_range_interval(visitor, node)
+                VisitMutAstPath::visit_mut_media_not(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_media_feature_range_interval(visitor, node)
+                VisitMutAstPath::visit_mut_media_not(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_in_parens(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
+    fn visit_mut_media_query_list(
+        &mut self,
+        node: &mut MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_not(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_not(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_query_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_query_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_or(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_or(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_querys(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_querys(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
+    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_query(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_media_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_media_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
+    fn visit_mut_named_namespace(
+        &mut self,
+        node: &mut NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_query_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_query_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_named_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_named_namespace(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
+    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_querys(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_querys(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_namespace(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
+    fn visit_mut_namespace_prefix(
+        &mut self,
+        node: &mut NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_media_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_media_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_namespace_prefix(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_namespace_prefix(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
+    fn visit_mut_namespace_prelude(
+        &mut self,
+        node: &mut NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_named_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_named_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_namespace_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_namespace_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
+    fn visit_mut_namespace_prelude_uri(
+        &mut self,
+        node: &mut NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_namespace_prelude_uri(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_namespace_prelude_uri(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
+    fn visit_mut_nesting_selector(
+        &mut self,
+        node: &mut NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_namespace_prefix(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_namespace_prefix(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_nesting_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_nesting_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_namespace_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_namespace_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
+    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_namespace_prelude_uri(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_namespace_prelude_uri(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_number_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_number_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
+    fn visit_mut_opt_at_rule_prelude(
+        &mut self,
+        node: &mut Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_nesting_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_nesting_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_at_rule_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_at_rule_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_number(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
+    fn visit_mut_opt_attribute_selector_matcher(
+        &mut self,
+        node: &mut Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_number_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_number_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_attribute_selector_matcher(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_attribute_selector_matcher(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_at_rule_prelude(
+    fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
-        node: Option<Box<AtRulePrelude>>,
-    ) -> Option<Box<AtRulePrelude>> {
+        node: &mut Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_at_rule_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_at_rule_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_attribute_selector_modifier(
+                    visitor, node, __ast_path,
+                )
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_attribute_selector_modifier(
+                    visitor, node, __ast_path,
+                )
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+    fn visit_mut_opt_attribute_selector_value(
+        &mut self,
+        node: &mut Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_attribute_selector_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_attribute_selector_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_matcher(
+    fn visit_mut_opt_combinator(
         &mut self,
-        node: Option<AttributeSelectorMatcher>,
-    ) -> Option<AttributeSelectorMatcher> {
+        node: &mut Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_opt_attribute_selector_matcher(visitor, node)
+                VisitMutAstPath::visit_mut_opt_combinator(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_attribute_selector_matcher(visitor, node)
+                VisitMutAstPath::visit_mut_opt_combinator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_modifier(
+    fn visit_mut_opt_container_name(
         &mut self,
-        node: Option<AttributeSelectorModifier>,
-    ) -> Option<AttributeSelectorModifier> {
+        node: &mut Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_opt_attribute_selector_modifier(visitor, node)
+                VisitMutAstPath::visit_mut_opt_container_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_attribute_selector_modifier(visitor, node)
+                VisitMutAstPath::visit_mut_opt_container_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_value(
+    fn visit_mut_opt_forgiving_selector_list(
         &mut self,
-        node: Option<AttributeSelectorValue>,
-    ) -> Option<AttributeSelectorValue> {
+        node: &mut Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_opt_attribute_selector_value(visitor, node)
+                VisitMutAstPath::visit_mut_opt_forgiving_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_attribute_selector_value(visitor, node)
+                VisitMutAstPath::visit_mut_opt_forgiving_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
+    fn visit_mut_opt_function(
+        &mut self,
+        node: &mut Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_combinator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_combinator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_container_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_container_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_forgiving_selector_list(
+    fn visit_mut_opt_import_conditions(
         &mut self,
-        node: Option<ForgivingSelectorList>,
-    ) -> Option<ForgivingSelectorList> {
+        node: &mut Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_opt_forgiving_selector_list(visitor, node)
+                VisitMutAstPath::visit_mut_opt_import_conditions(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_forgiving_selector_list(visitor, node)
+                VisitMutAstPath::visit_mut_opt_import_conditions(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
+    fn visit_mut_opt_import_layer_name(
+        &mut self,
+        node: &mut Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_function(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_import_layer_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_import_layer_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+    fn visit_mut_opt_important_flag(
+        &mut self,
+        node: &mut Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_important_flag(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_important_flag(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_import_conditions(
+    fn visit_mut_opt_media_condition_type(
         &mut self,
-        node: Option<Box<ImportConditions>>,
-    ) -> Option<Box<ImportConditions>> {
+        node: &mut Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_import_conditions(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_import_conditions(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_media_condition_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_media_condition_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_import_layer_name(
+    fn visit_mut_opt_media_query_list(
         &mut self,
-        node: Option<Box<ImportLayerName>>,
-    ) -> Option<Box<ImportLayerName>> {
+        node: &mut Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_import_layer_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_import_layer_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_media_query_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_media_query_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
+    fn visit_mut_opt_media_type(
+        &mut self,
+        node: &mut Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_important_flag(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_important_flag(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_media_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_media_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_media_condition_type(
+    fn visit_mut_opt_namespace(
         &mut self,
-        node: Option<Box<MediaConditionType>>,
-    ) -> Option<Box<MediaConditionType>> {
+        node: &mut Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_media_condition_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_media_condition_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_namespace(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_media_query_list(
+    fn visit_mut_opt_namespace_prefix(
         &mut self,
-        node: Option<Box<MediaQueryList>>,
-    ) -> Option<Box<MediaQueryList>> {
+        node: &mut Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_media_query_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_media_query_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_namespace_prefix(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_namespace_prefix(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
+    fn visit_mut_opt_nesting_selector(
+        &mut self,
+        node: &mut Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_media_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_media_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_nesting_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_nesting_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_number(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_number(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_namespace_prefix(
+    fn visit_mut_opt_page_selector_pseudos(
         &mut self,
-        node: Option<NamespacePrefix>,
-    ) -> Option<NamespacePrefix> {
+        node: &mut Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_namespace_prefix(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_namespace_prefix(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_page_selector_pseudos(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_page_selector_pseudos(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_nesting_selector(
+    fn visit_mut_opt_page_selector_type(
         &mut self,
-        node: Option<NestingSelector>,
-    ) -> Option<NestingSelector> {
-        match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_nesting_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_nesting_selector(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
+        node: &mut Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_number(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_page_selector_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_page_selector_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_page_selector_pseudos(
+    fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
-        node: Option<Vec<PageSelectorPseudo>>,
-    ) -> Option<Vec<PageSelectorPseudo>> {
+        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_page_selector_pseudos(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_pseudo_class_selector_childrens(
+                    visitor, node, __ast_path,
+                )
+            }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_page_selector_pseudos(visitor, node)
+                VisitMutAstPath::visit_mut_opt_pseudo_class_selector_childrens(
+                    visitor, node, __ast_path,
+                )
             }
         }
     }
 
     #[inline]
-    fn fold_opt_page_selector_type(
+    fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
-        node: Option<PageSelectorType>,
-    ) -> Option<PageSelectorType> {
+        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_page_selector_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_page_selector_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_pseudo_element_selector_childrens(
+                    visitor, node, __ast_path,
+                )
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_pseudo_element_selector_childrens(
+                    visitor, node, __ast_path,
+                )
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_pseudo_class_selector_childrens(
+    fn visit_mut_opt_simple_block(
         &mut self,
-        node: Option<Vec<PseudoClassSelectorChildren>>,
-    ) -> Option<Vec<PseudoClassSelectorChildren>> {
+        node: &mut Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_opt_pseudo_class_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_opt_simple_block(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_pseudo_class_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_opt_simple_block(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_pseudo_element_selector_childrens(
+    fn visit_mut_opt_type_selector(
         &mut self,
-        node: Option<Vec<PseudoElementSelectorChildren>>,
-    ) -> Option<Vec<PseudoElementSelectorChildren>> {
+        node: &mut Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_opt_pseudo_element_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_opt_type_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_pseudo_element_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_opt_type_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
+    fn visit_mut_opt_url_modifiers(
+        &mut self,
+        node: &mut Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_simple_block(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_simple_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_url_modifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_url_modifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_type_selector(
+    fn visit_mut_opt_url_value(
         &mut self,
-        node: Option<Box<TypeSelector>>,
-    ) -> Option<Box<TypeSelector>> {
+        node: &mut Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_type_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_type_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_url_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_url_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_url_modifiers(
-        &mut self,
-        node: Option<Vec<UrlModifier>>,
-    ) -> Option<Vec<UrlModifier>> {
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_url_modifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_url_modifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
+    fn visit_mut_page_selector_list(
+        &mut self,
+        node: &mut PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_url_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_url_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
+    fn visit_mut_page_selector_pseudo(
+        &mut self,
+        node: &mut PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_page_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_page_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_pseudo(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_pseudo(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
+    fn visit_mut_page_selector_pseudos(
+        &mut self,
+        node: &mut Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_pseudos(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_pseudos(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
+    fn visit_mut_page_selector_type(
+        &mut self,
+        node: &mut PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_pseudo(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_pseudo(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_page_selector_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_page_selector_pseudos(
+    fn visit_mut_page_selectors(
         &mut self,
-        node: Vec<PageSelectorPseudo>,
-    ) -> Vec<PageSelectorPseudo> {
+        node: &mut Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_pseudos(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_pseudos(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_page_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_page_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
+    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
+    fn visit_mut_pseudo_class_selector(
+        &mut self,
+        node: &mut PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_page_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_page_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_class_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_class_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
+    fn visit_mut_pseudo_class_selector_children(
+        &mut self,
+        node: &mut PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_class_selector_children(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_class_selector_children(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
+    fn visit_mut_pseudo_class_selector_childrens(
+        &mut self,
+        node: &mut Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_pseudo_class_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_pseudo_class_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_class_selector_childrens(
+                    visitor, node, __ast_path,
+                )
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_class_selector_childrens(
+                    visitor, node, __ast_path,
+                )
+            }
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_children(
+    fn visit_mut_pseudo_element_selector(
         &mut self,
-        node: PseudoClassSelectorChildren,
-    ) -> PseudoClassSelectorChildren {
+        node: &mut PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_pseudo_class_selector_children(visitor, node)
+                VisitMutAstPath::visit_mut_pseudo_element_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_pseudo_class_selector_children(visitor, node)
+                VisitMutAstPath::visit_mut_pseudo_element_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_childrens(
+    fn visit_mut_pseudo_element_selector_children(
         &mut self,
-        node: Vec<PseudoClassSelectorChildren>,
-    ) -> Vec<PseudoClassSelectorChildren> {
+        node: &mut PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_pseudo_class_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_pseudo_element_selector_children(
+                    visitor, node, __ast_path,
+                )
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_pseudo_class_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_pseudo_element_selector_children(
+                    visitor, node, __ast_path,
+                )
             }
         }
     }
 
     #[inline]
-    fn fold_pseudo_element_selector(
+    fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
-        node: PseudoElementSelector,
-    ) -> PseudoElementSelector {
+        node: &mut Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_pseudo_element_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_pseudo_element_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_element_selector_childrens(
+                    visitor, node, __ast_path,
+                )
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_pseudo_element_selector_childrens(
+                    visitor, node, __ast_path,
+                )
+            }
         }
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_children(
-        &mut self,
-        node: PseudoElementSelectorChildren,
-    ) -> PseudoElementSelectorChildren {
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_pseudo_element_selector_children(visitor, node)
+                VisitMutAstPath::visit_mut_qualified_rule(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_pseudo_element_selector_children(visitor, node)
+                VisitMutAstPath::visit_mut_qualified_rule(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_childrens(
+    fn visit_mut_qualified_rule_prelude(
         &mut self,
-        node: Vec<PseudoElementSelectorChildren>,
-    ) -> Vec<PseudoElementSelectorChildren> {
+        node: &mut QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_pseudo_element_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_qualified_rule_prelude(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_pseudo_element_selector_childrens(visitor, node)
+                VisitMutAstPath::visit_mut_qualified_rule_prelude(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
-        match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_qualified_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_qualified_rule(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
-        match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_qualified_rule_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_qualified_rule_prelude(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
+    fn visit_mut_query_in_parens(
+        &mut self,
+        node: &mut QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_query_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_query_in_parens(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_query_in_parens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_query_in_parens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
+    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ratio(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ratio(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ratio(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ratio(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
+    fn visit_mut_relative_selector(
+        &mut self,
+        node: &mut RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_relative_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_relative_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_relative_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_relative_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
+    fn visit_mut_relative_selector_list(
+        &mut self,
+        node: &mut RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_relative_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_relative_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_relative_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_relative_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
+    fn visit_mut_relative_selectors(
+        &mut self,
+        node: &mut Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_relative_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_relative_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_relative_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_relative_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
+    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_resolution(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_resolution(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_resolution(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_resolution(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule) -> Rule {
+    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_rule(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_rule(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_rule(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_rules(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_rules(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_rules(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_rules(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_scope_range(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_scope_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_scope_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_scope_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_sequence_of_custom_idents(
+    fn visit_mut_sequence_of_custom_idents(
         &mut self,
-        node: SequenceOfCustomIdents,
-    ) -> SequenceOfCustomIdents {
+        node: &mut SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_sequence_of_custom_idents(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_sequence_of_custom_idents(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_sequence_of_custom_idents(visitor, node)
+                VisitMutAstPath::visit_mut_sequence_of_custom_idents(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_simple_block(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_simple_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_simple_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_simple_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_size_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_size_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
+    fn visit_mut_size_feature_boolean(
+        &mut self,
+        node: &mut SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_boolean(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_boolean(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_boolean(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_boolean(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
+    fn visit_mut_size_feature_name(
+        &mut self,
+        node: &mut SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
+    fn visit_mut_size_feature_plain(
+        &mut self,
+        node: &mut SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_plain(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_plain(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_plain(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_plain(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
+    fn visit_mut_size_feature_range(
+        &mut self,
+        node: &mut SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_range(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_size_feature_range_comparison(
+    fn visit_mut_size_feature_range_comparison(
         &mut self,
-        node: SizeFeatureRangeComparison,
-    ) -> SizeFeatureRangeComparison {
+        node: &mut SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_size_feature_range_comparison(visitor, node)
+                VisitMutAstPath::visit_mut_size_feature_range_comparison(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_size_feature_range_comparison(visitor, node)
+                VisitMutAstPath::visit_mut_size_feature_range_comparison(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_size_feature_range_interval(
+    fn visit_mut_size_feature_range_interval(
         &mut self,
-        node: SizeFeatureRangeInterval,
-    ) -> SizeFeatureRangeInterval {
+        node: &mut SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_size_feature_range_interval(visitor, node)
+                VisitMutAstPath::visit_mut_size_feature_range_interval(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_size_feature_range_interval(visitor, node)
+                VisitMutAstPath::visit_mut_size_feature_range_interval(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
+    fn visit_mut_size_feature_value(
+        &mut self,
+        node: &mut SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_size_feature_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_span(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_str(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_str(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_style_block(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_style_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_style_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_style_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_stylesheet(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_stylesheet(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_stylesheet(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_stylesheet(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
+    fn visit_mut_subclass_selector(
+        &mut self,
+        node: &mut SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_subclass_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_subclass_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_subclass_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_subclass_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
+    fn visit_mut_subclass_selectors(
+        &mut self,
+        node: &mut Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_subclass_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_subclass_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_subclass_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_subclass_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_and(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
+    fn visit_mut_supports_condition(
+        &mut self,
+        node: &mut SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_condition(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_condition(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_condition_type(
+    fn visit_mut_supports_condition_type(
         &mut self,
-        node: SupportsConditionType,
-    ) -> SupportsConditionType {
+        node: &mut SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_condition_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_condition_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_condition_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_condition_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_condition_types(
+    fn visit_mut_supports_condition_types(
         &mut self,
-        node: Vec<SupportsConditionType>,
-    ) -> Vec<SupportsConditionType> {
+        node: &mut Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_condition_types(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_condition_types(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_condition_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_condition_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
+    fn visit_mut_supports_feature(
+        &mut self,
+        node: &mut SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_feature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_feature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
+    fn visit_mut_supports_in_parens(
+        &mut self,
+        node: &mut SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_in_parens(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_in_parens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_in_parens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_not(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_not(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_not(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_not(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_supports_or(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_supports_or(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_supports_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_supports_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
+    fn visit_mut_tag_name_selector(
+        &mut self,
+        node: &mut TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_tag_name_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_tag_name_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_tag_name_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_tag_name_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time) -> Time {
+    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_time(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_time(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_time(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_time(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
+    fn visit_mut_time_percentage(
+        &mut self,
+        node: &mut TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_time_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_time_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_time_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_time_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token) -> Token {
+    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_token(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_token(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_token(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_token(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_token_and_span(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_token_and_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_token_and_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_token_and_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_type_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_type_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_type_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_type_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_unicode_range(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_unicode_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_unicode_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_unicode_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
+    fn visit_mut_universal_selector(
+        &mut self,
+        node: &mut UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_universal_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_universal_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_universal_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_universal_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
+    fn visit_mut_unknown_dimension(
+        &mut self,
+        node: &mut UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_unknown_dimension(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_unknown_dimension(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_unknown_dimension(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_unknown_dimension(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url) -> Url {
+    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_url(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_url(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_url(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_url(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_url_key_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_url_key_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_url_key_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_url_key_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_url_modifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_url_modifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_url_modifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_url_modifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
+    fn visit_mut_url_modifiers(
+        &mut self,
+        node: &mut Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_url_modifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_url_modifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_url_modifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_url_modifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_url_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_url_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_url_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_url_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_url_value_raw(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_url_value_raw(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_url_value_raw(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_url_value_raw(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName) -> WqName {
+    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_wq_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_wq_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_wq_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_wq_name(visitor, node, __ast_path)
+            }
         }
     }
 }
-impl<V> Fold for ::swc_visit::Optional<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitMutAstPath for ::swc_visit::Optional<V>
 where
-    V: Fold,
+    V: VisitMutAstPath,
 {
     #[inline]
-    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
+    fn visit_mut_absolute_color_base(
+        &mut self,
+        node: &mut AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_absolute_color_base(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_absolute_color_base(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
+    fn visit_mut_alpha_value(&mut self, node: &mut AlphaValue, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_alpha_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_alpha_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
+    fn visit_mut_an_plus_b(&mut self, node: &mut AnPlusB, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_an_plus_b(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_an_plus_b(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
+    fn visit_mut_an_plus_b_notation(
+        &mut self,
+        node: &mut AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_an_plus_b_notation(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle) -> Angle {
+    fn visit_mut_angle(&mut self, node: &mut Angle, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_angle(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_angle(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
+    fn visit_mut_angle_percentage(
+        &mut self,
+        node: &mut AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_angle_percentage(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_angle_percentage(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
+    fn visit_mut_any_namespace(&mut self, node: &mut AnyNamespace, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_any_namespace(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_any_namespace(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
+    fn visit_mut_at_rule(&mut self, node: &mut AtRule, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_at_rule(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_at_rule(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
+    fn visit_mut_at_rule_name(&mut self, node: &mut AtRuleName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_at_rule_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_at_rule_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
+    fn visit_mut_at_rule_prelude(
+        &mut self,
+        node: &mut AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_at_rule_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_at_rule_prelude(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_atom(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_atom(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
+    fn visit_mut_attribute_selector(
+        &mut self,
+        node: &mut AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_attribute_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_attribute_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher(
+    fn visit_mut_attribute_selector_matcher(
         &mut self,
-        node: AttributeSelectorMatcher,
-    ) -> AttributeSelectorMatcher {
+        node: &mut AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_attribute_selector_matcher(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_matcher_value(
+    fn visit_mut_attribute_selector_matcher_value(
         &mut self,
-        node: AttributeSelectorMatcherValue,
-    ) -> AttributeSelectorMatcherValue {
+        node: &mut AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_attribute_selector_matcher_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_modifier(
+    fn visit_mut_attribute_selector_modifier(
         &mut self,
-        node: AttributeSelectorModifier,
-    ) -> AttributeSelectorModifier {
+        node: &mut AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_attribute_selector_modifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_attribute_selector_value(
+    fn visit_mut_attribute_selector_value(
         &mut self,
-        node: AttributeSelectorValue,
-    ) -> AttributeSelectorValue {
+        node: &mut AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_attribute_selector_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_attribute_selector_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
+    fn visit_mut_bin_op(&mut self, node: &mut BinOp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_bin_op(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_bin_op(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
+    fn visit_mut_calc_operator(&mut self, node: &mut CalcOperator, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_calc_operator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_operator(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
+    fn visit_mut_calc_operator_type(
+        &mut self,
+        node: &mut CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_calc_operator_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_operator_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
+    fn visit_mut_calc_product(&mut self, node: &mut CalcProduct, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_calc_product(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_product(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_product_or_operator(
+    fn visit_mut_calc_product_or_operator(
         &mut self,
-        node: CalcProductOrOperator,
-    ) -> CalcProductOrOperator {
+        node: &mut CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_calc_product_or_operator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_product_or_operators(
+    fn visit_mut_calc_product_or_operators(
         &mut self,
-        node: Vec<CalcProductOrOperator>,
-    ) -> Vec<CalcProductOrOperator> {
+        node: &mut Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_calc_product_or_operators(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
+    fn visit_mut_calc_sum(&mut self, node: &mut CalcSum, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_calc_sum(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_sum(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
+    fn visit_mut_calc_value(&mut self, node: &mut CalcValue, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_calc_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
+    fn visit_mut_calc_value_or_operator(
+        &mut self,
+        node: &mut CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_calc_value_or_operator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_calc_value_or_operators(
+    fn visit_mut_calc_value_or_operators(
         &mut self,
-        node: Vec<CalcValueOrOperator>,
-    ) -> Vec<CalcValueOrOperator> {
+        node: &mut Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_calc_value_or_operators(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
+    fn visit_mut_class_selector(&mut self, node: &mut ClassSelector, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_class_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
+    fn visit_mut_cmyk_component(&mut self, node: &mut CmykComponent, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_cmyk_component(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_cmyk_component(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color) -> Color {
+    fn visit_mut_color(&mut self, node: &mut Color, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_color(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_color(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
+    fn visit_mut_color_profile_name(
+        &mut self,
+        node: &mut ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_color_profile_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_color_profile_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
+    fn visit_mut_combinator(&mut self, node: &mut Combinator, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_combinator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_combinator(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
+    fn visit_mut_combinator_value(
+        &mut self,
+        node: &mut CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_combinator_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_combinator_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
+    fn visit_mut_complex_selector(
+        &mut self,
+        node: &mut ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_complex_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_complex_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_complex_selector_children(
+    fn visit_mut_complex_selector_children(
         &mut self,
-        node: ComplexSelectorChildren,
-    ) -> ComplexSelectorChildren {
+        node: &mut ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_complex_selector_children(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_complex_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_complex_selector_childrens(
+    fn visit_mut_complex_selector_childrens(
         &mut self,
-        node: Vec<ComplexSelectorChildren>,
-    ) -> Vec<ComplexSelectorChildren> {
+        node: &mut Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_complex_selector_childrens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
+    fn visit_mut_complex_selectors(
+        &mut self,
+        node: &mut Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_complex_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_complex_selectors(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
+    fn visit_mut_component_value(
+        &mut self,
+        node: &mut ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_component_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_component_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
+    fn visit_mut_component_values(
+        &mut self,
+        node: &mut Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_component_values(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_component_values(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
+    fn visit_mut_compound_selector(
+        &mut self,
+        node: &mut CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_compound_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_compound_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
+    fn visit_mut_compound_selector_list(
+        &mut self,
+        node: &mut CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_compound_selector_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_compound_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
+    fn visit_mut_compound_selectors(
+        &mut self,
+        node: &mut Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_compound_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_compound_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
+    fn visit_mut_container_condition(
+        &mut self,
+        node: &mut ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_container_condition(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_condition(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
+    fn visit_mut_container_name(&mut self, node: &mut ContainerName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_container_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
+    fn visit_mut_container_query(
+        &mut self,
+        node: &mut ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_container_query(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_query(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
+    fn visit_mut_container_query_and(
+        &mut self,
+        node: &mut ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_container_query_and(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_query_and(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
+    fn visit_mut_container_query_not(
+        &mut self,
+        node: &mut ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_container_query_not(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_query_not(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
+    fn visit_mut_container_query_or(
+        &mut self,
+        node: &mut ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_container_query_or(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_query_or(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
+    fn visit_mut_container_query_type(
+        &mut self,
+        node: &mut ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_container_query_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_query_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_container_query_types(
+    fn visit_mut_container_query_types(
         &mut self,
-        node: Vec<ContainerQueryType>,
-    ) -> Vec<ContainerQueryType> {
+        node: &mut Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_container_query_types(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_container_query_types(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
+    fn visit_mut_custom_highlight_name(
+        &mut self,
+        node: &mut CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_custom_highlight_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_custom_highlight_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
+    fn visit_mut_custom_ident(&mut self, node: &mut CustomIdent, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_custom_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_custom_ident(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
+    fn visit_mut_custom_idents(
+        &mut self,
+        node: &mut Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_custom_idents(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_custom_idents(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
+    fn visit_mut_custom_media_query(
+        &mut self,
+        node: &mut CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_custom_media_query(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_custom_media_query(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_custom_media_query_media_type(
+    fn visit_mut_custom_media_query_media_type(
         &mut self,
-        node: CustomMediaQueryMediaType,
-    ) -> CustomMediaQueryMediaType {
+        node: &mut CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_custom_media_query_media_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
+    fn visit_mut_custom_property_name(
+        &mut self,
+        node: &mut CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_custom_property_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_custom_property_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
+    fn visit_mut_dashed_ident(&mut self, node: &mut DashedIdent, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_dashed_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_dashed_ident(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
+    fn visit_mut_declaration(&mut self, node: &mut Declaration, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_declaration(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_declaration(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
+    fn visit_mut_declaration_name(
+        &mut self,
+        node: &mut DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_declaration_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_declaration_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
+    fn visit_mut_declaration_or_at_rule(
+        &mut self,
+        node: &mut DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_declaration_or_at_rule(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
+    fn visit_mut_delimiter(&mut self, node: &mut Delimiter, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_delimiter(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_delimiter(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
+    fn visit_mut_delimiter_value(
+        &mut self,
+        node: &mut DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_delimiter_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_delimiter_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
+    fn visit_mut_dimension(&mut self, node: &mut Dimension, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_dimension(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_dimension(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
+    fn visit_mut_dimension_token(
+        &mut self,
+        node: &mut DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_dimension_token(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_dimension_token(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
+    fn visit_mut_document_prelude(
+        &mut self,
+        node: &mut DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_document_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_document_prelude(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_document_prelude_matching_function(
+    fn visit_mut_document_prelude_matching_function(
         &mut self,
-        node: DocumentPreludeMatchingFunction,
-    ) -> DocumentPreludeMatchingFunction {
+        node: &mut DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_document_prelude_matching_function(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_document_prelude_matching_functions(
+    fn visit_mut_document_prelude_matching_functions(
         &mut self,
-        node: Vec<DocumentPreludeMatchingFunction>,
-    ) -> Vec<DocumentPreludeMatchingFunction> {
+        node: &mut Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_document_prelude_matching_functions(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
+    fn visit_mut_extension_name(&mut self, node: &mut ExtensionName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_extension_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_extension_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
+    fn visit_mut_family_name(&mut self, node: &mut FamilyName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_family_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_family_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
+    fn visit_mut_family_names(&mut self, node: &mut Vec<FamilyName>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_family_names(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_family_names(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex) -> Flex {
+    fn visit_mut_flex(&mut self, node: &mut Flex, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_flex(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_flex(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_font_feature_values_prelude(
+    fn visit_mut_font_feature_values_prelude(
         &mut self,
-        node: FontFeatureValuesPrelude,
-    ) -> FontFeatureValuesPrelude {
+        node: &mut FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_font_feature_values_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_forgiving_complex_selector(
+    fn visit_mut_forgiving_complex_selector(
         &mut self,
-        node: ForgivingComplexSelector,
-    ) -> ForgivingComplexSelector {
+        node: &mut ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_forgiving_complex_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_forgiving_complex_selectors(
+    fn visit_mut_forgiving_complex_selectors(
         &mut self,
-        node: Vec<ForgivingComplexSelector>,
-    ) -> Vec<ForgivingComplexSelector> {
+        node: &mut Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_forgiving_complex_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector(
+    fn visit_mut_forgiving_relative_selector(
         &mut self,
-        node: ForgivingRelativeSelector,
-    ) -> ForgivingRelativeSelector {
+        node: &mut ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_forgiving_relative_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_forgiving_relative_selector_list(
+    fn visit_mut_forgiving_relative_selector_list(
         &mut self,
-        node: ForgivingRelativeSelectorList,
-    ) -> ForgivingRelativeSelectorList {
+        node: &mut ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_forgiving_relative_selector_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_forgiving_relative_selectors(
+    fn visit_mut_forgiving_relative_selectors(
         &mut self,
-        node: Vec<ForgivingRelativeSelector>,
-    ) -> Vec<ForgivingRelativeSelector> {
+        node: &mut Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_forgiving_relative_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_forgiving_selector_list(
+    fn visit_mut_forgiving_selector_list(
         &mut self,
-        node: ForgivingSelectorList,
-    ) -> ForgivingSelectorList {
+        node: &mut ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_forgiving_selector_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
+    fn visit_mut_frequency(&mut self, node: &mut Frequency, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_frequency(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_frequency(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
+    fn visit_mut_frequency_percentage(
+        &mut self,
+        node: &mut FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_frequency_percentage(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_frequency_percentage(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_function(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_function(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
+    fn visit_mut_function_name(&mut self, node: &mut FunctionName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_function_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_function_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
+    fn visit_mut_general_enclosed(
+        &mut self,
+        node: &mut GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_general_enclosed(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_general_enclosed(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
+    fn visit_mut_hex_color(&mut self, node: &mut HexColor, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_hex_color(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_hex_color(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue) -> Hue {
+    fn visit_mut_hue(&mut self, node: &mut Hue, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_hue(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_hue(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
+    fn visit_mut_id_selector(&mut self, node: &mut IdSelector, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_id_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_id_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ident(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
+    fn visit_mut_idents(&mut self, node: &mut Vec<Ident>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_idents(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_idents(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
+    fn visit_mut_import_conditions(
+        &mut self,
+        node: &mut ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_conditions(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_conditions(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
+    fn visit_mut_import_href(&mut self, node: &mut ImportHref, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_import_href(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_href(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
+    fn visit_mut_import_layer_name(
+        &mut self,
+        node: &mut ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_layer_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_layer_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
+    fn visit_mut_import_prelude(&mut self, node: &mut ImportPrelude, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_import_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_prelude(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
+    fn visit_mut_important_flag(&mut self, node: &mut ImportantFlag, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_important_flag(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_important_flag(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer) -> Integer {
+    fn visit_mut_integer(&mut self, node: &mut Integer, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_integer(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_integer(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
+    fn visit_mut_keyframe_block(&mut self, node: &mut KeyframeBlock, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_keyframe_block(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_keyframe_block(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
+    fn visit_mut_keyframe_selector(
+        &mut self,
+        node: &mut KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_keyframe_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_keyframe_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
+    fn visit_mut_keyframe_selectors(
+        &mut self,
+        node: &mut Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_keyframe_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_keyframe_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
+    fn visit_mut_keyframes_name(&mut self, node: &mut KeyframesName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_keyframes_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_keyframes_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_function(
+    fn visit_mut_keyframes_pseudo_function(
         &mut self,
-        node: KeyframesPseudoFunction,
-    ) -> KeyframesPseudoFunction {
+        node: &mut KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_keyframes_pseudo_function(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_keyframes_pseudo_prefix(
+    fn visit_mut_keyframes_pseudo_prefix(
         &mut self,
-        node: KeyframesPseudoPrefix,
-    ) -> KeyframesPseudoPrefix {
+        node: &mut KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_keyframes_pseudo_prefix(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
+    fn visit_mut_layer_name(&mut self, node: &mut LayerName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_layer_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_layer_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
+    fn visit_mut_layer_name_list(
+        &mut self,
+        node: &mut LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_layer_name_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_layer_name_list(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
+    fn visit_mut_layer_names(&mut self, node: &mut Vec<LayerName>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_layer_names(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_layer_names(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
+    fn visit_mut_layer_prelude(&mut self, node: &mut LayerPrelude, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_layer_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_layer_prelude(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length) -> Length {
+    fn visit_mut_length(&mut self, node: &mut Length, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_length(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_length(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
+    fn visit_mut_length_percentage(
+        &mut self,
+        node: &mut LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_length_percentage(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_length_percentage(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_list_of_component_values(
+    fn visit_mut_list_of_component_values(
         &mut self,
-        node: ListOfComponentValues,
-    ) -> ListOfComponentValues {
+        node: &mut ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_list_of_component_values(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_list_of_component_values(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
+    fn visit_mut_media_and(&mut self, node: &mut MediaAnd, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_media_and(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_and(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
+    fn visit_mut_media_condition(
+        &mut self,
+        node: &mut MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_condition(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_condition(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_condition_all_type(
+    fn visit_mut_media_condition_all_type(
         &mut self,
-        node: MediaConditionAllType,
-    ) -> MediaConditionAllType {
+        node: &mut MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_condition_all_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_condition_all_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_condition_all_types(
+    fn visit_mut_media_condition_all_types(
         &mut self,
-        node: Vec<MediaConditionAllType>,
-    ) -> Vec<MediaConditionAllType> {
+        node: &mut Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_condition_all_types(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_condition_all_types(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
+    fn visit_mut_media_condition_type(
+        &mut self,
+        node: &mut MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_condition_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_condition_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_condition_without_or(
+    fn visit_mut_media_condition_without_or(
         &mut self,
-        node: MediaConditionWithoutOr,
-    ) -> MediaConditionWithoutOr {
+        node: &mut MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_condition_without_or(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_condition_without_or(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_condition_without_or_type(
+    fn visit_mut_media_condition_without_or_type(
         &mut self,
-        node: MediaConditionWithoutOrType,
-    ) -> MediaConditionWithoutOrType {
+        node: &mut MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_condition_without_or_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_condition_without_or_types(
+    fn visit_mut_media_condition_without_or_types(
         &mut self,
-        node: Vec<MediaConditionWithoutOrType>,
-    ) -> Vec<MediaConditionWithoutOrType> {
+        node: &mut Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_condition_without_or_types(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
+    fn visit_mut_media_feature(&mut self, node: &mut MediaFeature, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_media_feature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
+    fn visit_mut_media_feature_boolean(
+        &mut self,
+        node: &mut MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_feature_boolean(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature_boolean(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
+    fn visit_mut_media_feature_name(
+        &mut self,
+        node: &mut MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_feature_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
+    fn visit_mut_media_feature_plain(
+        &mut self,
+        node: &mut MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_feature_plain(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature_plain(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
+    fn visit_mut_media_feature_range(
+        &mut self,
+        node: &mut MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_feature_range(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature_range(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature_range_comparison(
+    fn visit_mut_media_feature_range_comparison(
         &mut self,
-        node: MediaFeatureRangeComparison,
-    ) -> MediaFeatureRangeComparison {
+        node: &mut MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_feature_range_comparison(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature_range_interval(
+    fn visit_mut_media_feature_range_interval(
         &mut self,
-        node: MediaFeatureRangeInterval,
-    ) -> MediaFeatureRangeInterval {
+        node: &mut MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_feature_range_interval(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
+    fn visit_mut_media_feature_value(
+        &mut self,
+        node: &mut MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_feature_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_feature_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
+    fn visit_mut_media_in_parens(
+        &mut self,
+        node: &mut MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_in_parens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_in_parens(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
+    fn visit_mut_media_not(&mut self, node: &mut MediaNot, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_media_not(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_not(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
+    fn visit_mut_media_or(&mut self, node: &mut MediaOr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_media_or(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_or(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
+    fn visit_mut_media_query(&mut self, node: &mut MediaQuery, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_media_query(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_query(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
+    fn visit_mut_media_query_list(
+        &mut self,
+        node: &mut MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_media_query_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_query_list(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
+    fn visit_mut_media_querys(&mut self, node: &mut Vec<MediaQuery>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_media_querys(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_querys(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
+    fn visit_mut_media_type(&mut self, node: &mut MediaType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_media_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_media_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
+    fn visit_mut_named_namespace(
+        &mut self,
+        node: &mut NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_named_namespace(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_named_namespace(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
+    fn visit_mut_namespace(&mut self, node: &mut Namespace, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_namespace(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_namespace(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
+    fn visit_mut_namespace_prefix(
+        &mut self,
+        node: &mut NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_namespace_prefix(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_namespace_prefix(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
+    fn visit_mut_namespace_prelude(
+        &mut self,
+        node: &mut NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_namespace_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_namespace_prelude(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
+    fn visit_mut_namespace_prelude_uri(
+        &mut self,
+        node: &mut NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_namespace_prelude_uri(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
+    fn visit_mut_nesting_selector(
+        &mut self,
+        node: &mut NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_nesting_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_nesting_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_number(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_number(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
+    fn visit_mut_number_type(&mut self, node: &mut NumberType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_number_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_number_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_at_rule_prelude(
+    fn visit_mut_opt_at_rule_prelude(
         &mut self,
-        node: Option<Box<AtRulePrelude>>,
-    ) -> Option<Box<AtRulePrelude>> {
+        node: &mut Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_at_rule_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_atom(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_atom(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_matcher(
+    fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
-        node: Option<AttributeSelectorMatcher>,
-    ) -> Option<AttributeSelectorMatcher> {
+        node: &mut Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_attribute_selector_matcher(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_modifier(
+    fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
-        node: Option<AttributeSelectorModifier>,
-    ) -> Option<AttributeSelectorModifier> {
+        node: &mut Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_attribute_selector_modifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_attribute_selector_value(
+    fn visit_mut_opt_attribute_selector_value(
         &mut self,
-        node: Option<AttributeSelectorValue>,
-    ) -> Option<AttributeSelectorValue> {
+        node: &mut Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_attribute_selector_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
+    fn visit_mut_opt_combinator(
+        &mut self,
+        node: &mut Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_combinator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_combinator(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
+    fn visit_mut_opt_container_name(
+        &mut self,
+        node: &mut Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_container_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_container_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_forgiving_selector_list(
+    fn visit_mut_opt_forgiving_selector_list(
         &mut self,
-        node: Option<ForgivingSelectorList>,
-    ) -> Option<ForgivingSelectorList> {
+        node: &mut Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_forgiving_selector_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
+    fn visit_mut_opt_function(
+        &mut self,
+        node: &mut Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_function(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_function(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ident(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_import_conditions(
+    fn visit_mut_opt_import_conditions(
         &mut self,
-        node: Option<Box<ImportConditions>>,
-    ) -> Option<Box<ImportConditions>> {
+        node: &mut Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_import_conditions(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_import_conditions(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_import_layer_name(
+    fn visit_mut_opt_import_layer_name(
         &mut self,
-        node: Option<Box<ImportLayerName>>,
-    ) -> Option<Box<ImportLayerName>> {
+        node: &mut Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_import_layer_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
+    fn visit_mut_opt_important_flag(
+        &mut self,
+        node: &mut Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_important_flag(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_important_flag(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_media_condition_type(
+    fn visit_mut_opt_media_condition_type(
         &mut self,
-        node: Option<Box<MediaConditionType>>,
-    ) -> Option<Box<MediaConditionType>> {
+        node: &mut Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_media_condition_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_media_query_list(
+    fn visit_mut_opt_media_query_list(
         &mut self,
-        node: Option<Box<MediaQueryList>>,
-    ) -> Option<Box<MediaQueryList>> {
+        node: &mut Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_media_query_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_media_query_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
+    fn visit_mut_opt_media_type(
+        &mut self,
+        node: &mut Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_media_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_media_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
+    fn visit_mut_opt_namespace(
+        &mut self,
+        node: &mut Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_namespace(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_namespace(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_namespace_prefix(
+    fn visit_mut_opt_namespace_prefix(
         &mut self,
-        node: Option<NamespacePrefix>,
-    ) -> Option<NamespacePrefix> {
+        node: &mut Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_namespace_prefix(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_nesting_selector(
+    fn visit_mut_opt_nesting_selector(
         &mut self,
-        node: Option<NestingSelector>,
-    ) -> Option<NestingSelector> {
+        node: &mut Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_nesting_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
+    fn visit_mut_opt_number(&mut self, node: &mut Option<Number>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_number(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_number(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_page_selector_pseudos(
+    fn visit_mut_opt_page_selector_pseudos(
         &mut self,
-        node: Option<Vec<PageSelectorPseudo>>,
-    ) -> Option<Vec<PageSelectorPseudo>> {
+        node: &mut Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_page_selector_pseudos(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_page_selector_type(
+    fn visit_mut_opt_page_selector_type(
         &mut self,
-        node: Option<PageSelectorType>,
-    ) -> Option<PageSelectorType> {
+        node: &mut Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_page_selector_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_pseudo_class_selector_childrens(
+    fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoClassSelectorChildren>>,
-    ) -> Option<Vec<PseudoClassSelectorChildren>> {
+        node: &mut Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_pseudo_class_selector_childrens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_pseudo_element_selector_childrens(
+    fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
-        node: Option<Vec<PseudoElementSelectorChildren>>,
-    ) -> Option<Vec<PseudoElementSelectorChildren>> {
+        node: &mut Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_pseudo_element_selector_childrens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
+    fn visit_mut_opt_simple_block(
+        &mut self,
+        node: &mut Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_simple_block(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_simple_block(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_type_selector(
+    fn visit_mut_opt_type_selector(
         &mut self,
-        node: Option<Box<TypeSelector>>,
-    ) -> Option<Box<TypeSelector>> {
+        node: &mut Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_type_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_type_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_url_modifiers(
+    fn visit_mut_opt_url_modifiers(
         &mut self,
-        node: Option<Vec<UrlModifier>>,
-    ) -> Option<Vec<UrlModifier>> {
+        node: &mut Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_url_modifiers(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
+    fn visit_mut_opt_url_value(
+        &mut self,
+        node: &mut Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_url_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_url_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
+    fn visit_mut_page_selector(&mut self, node: &mut PageSelector, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_page_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_page_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
+    fn visit_mut_page_selector_list(
+        &mut self,
+        node: &mut PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_page_selector_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_page_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
+    fn visit_mut_page_selector_pseudo(
+        &mut self,
+        node: &mut PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_page_selector_pseudo(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_page_selector_pseudos(
+    fn visit_mut_page_selector_pseudos(
         &mut self,
-        node: Vec<PageSelectorPseudo>,
-    ) -> Vec<PageSelectorPseudo> {
+        node: &mut Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_page_selector_pseudos(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
+    fn visit_mut_page_selector_type(
+        &mut self,
+        node: &mut PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_page_selector_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_page_selector_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
+    fn visit_mut_page_selectors(
+        &mut self,
+        node: &mut Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_page_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_page_selectors(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
+    fn visit_mut_percentage(&mut self, node: &mut Percentage, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_percentage(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_percentage(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
+    fn visit_mut_pseudo_class_selector(
+        &mut self,
+        node: &mut PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_pseudo_class_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_children(
+    fn visit_mut_pseudo_class_selector_children(
         &mut self,
-        node: PseudoClassSelectorChildren,
-    ) -> PseudoClassSelectorChildren {
+        node: &mut PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_pseudo_class_selector_children(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector_childrens(
+    fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
-        node: Vec<PseudoClassSelectorChildren>,
-    ) -> Vec<PseudoClassSelectorChildren> {
+        node: &mut Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_pseudo_class_selector_childrens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pseudo_element_selector(
+    fn visit_mut_pseudo_element_selector(
         &mut self,
-        node: PseudoElementSelector,
-    ) -> PseudoElementSelector {
+        node: &mut PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_pseudo_element_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_children(
+    fn visit_mut_pseudo_element_selector_children(
         &mut self,
-        node: PseudoElementSelectorChildren,
-    ) -> PseudoElementSelectorChildren {
+        node: &mut PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_pseudo_element_selector_children(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pseudo_element_selector_childrens(
+    fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
-        node: Vec<PseudoElementSelectorChildren>,
-    ) -> Vec<PseudoElementSelectorChildren> {
+        node: &mut Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_pseudo_element_selector_childrens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
+    fn visit_mut_qualified_rule(&mut self, node: &mut QualifiedRule, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_qualified_rule(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_qualified_rule(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
+    fn visit_mut_qualified_rule_prelude(
+        &mut self,
+        node: &mut QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_qualified_rule_prelude(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
+    fn visit_mut_query_in_parens(
+        &mut self,
+        node: &mut QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_query_in_parens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_query_in_parens(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
+    fn visit_mut_ratio(&mut self, node: &mut Ratio, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ratio(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ratio(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
+    fn visit_mut_relative_selector(
+        &mut self,
+        node: &mut RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_relative_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_relative_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
+    fn visit_mut_relative_selector_list(
+        &mut self,
+        node: &mut RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_relative_selector_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_relative_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
+    fn visit_mut_relative_selectors(
+        &mut self,
+        node: &mut Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_relative_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_relative_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
+    fn visit_mut_resolution(&mut self, node: &mut Resolution, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_resolution(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_resolution(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule) -> Rule {
+    fn visit_mut_rule(&mut self, node: &mut Rule, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_rule(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_rule(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
+    fn visit_mut_rules(&mut self, node: &mut Vec<Rule>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_rules(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_rules(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
+    fn visit_mut_scope_range(&mut self, node: &mut ScopeRange, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_scope_range(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_scope_range(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
+    fn visit_mut_selector_list(&mut self, node: &mut SelectorList, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_selector_list(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_selector_list(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_sequence_of_custom_idents(
+    fn visit_mut_sequence_of_custom_idents(
         &mut self,
-        node: SequenceOfCustomIdents,
-    ) -> SequenceOfCustomIdents {
+        node: &mut SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_sequence_of_custom_idents(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
+    fn visit_mut_simple_block(&mut self, node: &mut SimpleBlock, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_simple_block(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_simple_block(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
+    fn visit_mut_size_feature(&mut self, node: &mut SizeFeature, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_size_feature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
+    fn visit_mut_size_feature_boolean(
+        &mut self,
+        node: &mut SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_size_feature_boolean(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature_boolean(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
+    fn visit_mut_size_feature_name(
+        &mut self,
+        node: &mut SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_size_feature_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
+    fn visit_mut_size_feature_plain(
+        &mut self,
+        node: &mut SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_size_feature_plain(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature_plain(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
+    fn visit_mut_size_feature_range(
+        &mut self,
+        node: &mut SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_size_feature_range(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature_range(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature_range_comparison(
+    fn visit_mut_size_feature_range_comparison(
         &mut self,
-        node: SizeFeatureRangeComparison,
-    ) -> SizeFeatureRangeComparison {
+        node: &mut SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_size_feature_range_comparison(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature_range_interval(
+    fn visit_mut_size_feature_range_interval(
         &mut self,
-        node: SizeFeatureRangeInterval,
-    ) -> SizeFeatureRangeInterval {
+        node: &mut SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_size_feature_range_interval(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
+    fn visit_mut_size_feature_value(
+        &mut self,
+        node: &mut SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_size_feature_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_size_feature_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_span(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_span(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_str(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_str(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
+    fn visit_mut_style_block(&mut self, node: &mut StyleBlock, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_style_block(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_style_block(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
+    fn visit_mut_stylesheet(&mut self, node: &mut Stylesheet, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_stylesheet(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_stylesheet(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
+    fn visit_mut_subclass_selector(
+        &mut self,
+        node: &mut SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_subclass_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_subclass_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
+    fn visit_mut_subclass_selectors(
+        &mut self,
+        node: &mut Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_subclass_selectors(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_subclass_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
+    fn visit_mut_supports_and(&mut self, node: &mut SupportsAnd, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_supports_and(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_and(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
+    fn visit_mut_supports_condition(
+        &mut self,
+        node: &mut SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_supports_condition(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_condition(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_condition_type(
+    fn visit_mut_supports_condition_type(
         &mut self,
-        node: SupportsConditionType,
-    ) -> SupportsConditionType {
+        node: &mut SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_supports_condition_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_condition_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_condition_types(
+    fn visit_mut_supports_condition_types(
         &mut self,
-        node: Vec<SupportsConditionType>,
-    ) -> Vec<SupportsConditionType> {
+        node: &mut Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_supports_condition_types(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_condition_types(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
+    fn visit_mut_supports_feature(
+        &mut self,
+        node: &mut SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_supports_feature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_feature(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
+    fn visit_mut_supports_in_parens(
+        &mut self,
+        node: &mut SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_supports_in_parens(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_in_parens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
+    fn visit_mut_supports_not(&mut self, node: &mut SupportsNot, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_supports_not(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_not(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
+    fn visit_mut_supports_or(&mut self, node: &mut SupportsOr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_supports_or(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_supports_or(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
+    fn visit_mut_tag_name_selector(
+        &mut self,
+        node: &mut TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_tag_name_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_tag_name_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time) -> Time {
+    fn visit_mut_time(&mut self, node: &mut Time, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_time(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_time(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
+    fn visit_mut_time_percentage(
+        &mut self,
+        node: &mut TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_time_percentage(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_time_percentage(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token) -> Token {
+    fn visit_mut_token(&mut self, node: &mut Token, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_token(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_token(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
+    fn visit_mut_token_and_span(&mut self, node: &mut TokenAndSpan, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_token_and_span(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_token_and_span(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
+    fn visit_mut_type_selector(&mut self, node: &mut TypeSelector, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_type_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_type_selector(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
+    fn visit_mut_unicode_range(&mut self, node: &mut UnicodeRange, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_unicode_range(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_unicode_range(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
+    fn visit_mut_universal_selector(
+        &mut self,
+        node: &mut UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_universal_selector(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_universal_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
+    fn visit_mut_unknown_dimension(
+        &mut self,
+        node: &mut UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_unknown_dimension(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_unknown_dimension(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url) -> Url {
+    fn visit_mut_url(&mut self, node: &mut Url, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_url(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_url(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
+    fn visit_mut_url_key_value(&mut self, node: &mut UrlKeyValue, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_url_key_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_url_key_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
+    fn visit_mut_url_modifier(&mut self, node: &mut UrlModifier, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_url_modifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_url_modifier(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
+    fn visit_mut_url_modifiers(
+        &mut self,
+        node: &mut Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_url_modifiers(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_url_modifiers(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
+    fn visit_mut_url_value(&mut self, node: &mut UrlValue, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_url_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_url_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
+    fn visit_mut_url_value_raw(&mut self, node: &mut UrlValueRaw, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_url_value_raw(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_url_value_raw(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName) -> WqName {
+    fn visit_mut_wq_name(&mut self, node: &mut WqName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_wq_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_wq_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait FoldWith<V: ?Sized + Fold> {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait VisitMutWithAstPath<V: ?Sized + VisitMutAstPath> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn fold_with(self, visitor: &mut V) -> Self;
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn fold_children_with(self, visitor: &mut V) -> Self;
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AbsoluteColorBase {
-    #[doc = "Calls [Fold`::fold_absolute_color_base`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_absolute_color_base(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AbsoluteColorBase {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_absolute_color_base`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_absolute_color_base(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AbsoluteColorBase::HexColor { 0: _field_0 } => {
-                let _field_0 = <HexColor as FoldWith<V>>::fold_with(_field_0, visitor);
-                AbsoluteColorBase::HexColor { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
+                    self::fields::AbsoluteColorBaseField::HexColor,
+                ));
+                <HexColor as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
+                    self::fields::AbsoluteColorBaseField::NamedColorOrTransparent,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AbsoluteColorBase::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                AbsoluteColorBase::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
+                    self::fields::AbsoluteColorBaseField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AlphaValue {
-    #[doc = "Calls [Fold`::fold_alpha_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_alpha_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AlphaValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_alpha_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_alpha_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AlphaValue::Number { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                AlphaValue::Number { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
+                    self::fields::AlphaValueField::Number,
+                ));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AlphaValue::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                AlphaValue::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
+                    self::fields::AlphaValueField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AnPlusB {
-    #[doc = "Calls [Fold`::fold_an_plus_b`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_an_plus_b(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnPlusB {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_an_plus_b`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_an_plus_b(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AnPlusB::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                AnPlusB::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::AnPlusB(self::fields::AnPlusBField::Ident));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AnPlusB::AnPlusBNotation { 0: _field_0 } => {
-                let _field_0 = <AnPlusBNotation as FoldWith<V>>::fold_with(_field_0, visitor);
-                AnPlusB::AnPlusBNotation { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusB(
+                    self::fields::AnPlusBField::AnPlusBNotation,
+                ));
+                <AnPlusBNotation as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AnPlusBNotation {
-    #[doc = "Calls [Fold`::fold_an_plus_b_notation`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_an_plus_b_notation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnPlusBNotation {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_an_plus_b_notation`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_an_plus_b_notation(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AnPlusBNotation {
                 span,
@@ -82425,78 +63229,149 @@ impl<V: ?Sized + Fold> FoldWith<V> for AnPlusBNotation {
                 b,
                 b_raw,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let a_raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(a_raw, visitor) };
-                let b_raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(b_raw, visitor) };
-                AnPlusBNotation {
-                    span,
-                    a,
-                    a_raw,
-                    b,
-                    b_raw,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
+                        self::fields::AnPlusBNotationField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
+                        self::fields::AnPlusBNotationField::ARaw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        a_raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
+                        self::fields::AnPlusBNotationField::BRaw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        b_raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Angle {
-    #[doc = "Calls [Fold`::fold_angle`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_angle(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Angle {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_angle`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_angle(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Angle { span, value, unit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
-                Angle { span, value, unit }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Angle(self::fields::AngleField::Value));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Unit));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AnglePercentage {
-    #[doc = "Calls [Fold`::fold_angle_percentage`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_angle_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnglePercentage {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_angle_percentage`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_angle_percentage(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AnglePercentage::Angle { 0: _field_0 } => {
-                let _field_0 = <Angle as FoldWith<V>>::fold_with(_field_0, visitor);
-                AnglePercentage::Angle { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
+                    self::fields::AnglePercentageField::Angle,
+                ));
+                <Angle as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AnglePercentage::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                AnglePercentage::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
+                    self::fields::AnglePercentageField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AnyNamespace {
-    #[doc = "Calls [Fold`::fold_any_namespace`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_any_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AnyNamespace {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_any_namespace`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_any_namespace(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AnyNamespace { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                AnyNamespace { span }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnyNamespace(
+                        self::fields::AnyNamespaceField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AtRule {
-    #[doc = "Calls [Fold`::fold_at_rule`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_at_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AtRule {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_at_rule`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_at_rule(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AtRule {
                 span,
@@ -82504,135 +63379,291 @@ impl<V: ?Sized + Fold> FoldWith<V> for AtRule {
                 prelude,
                 block,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <AtRuleName as FoldWith<V>>::fold_with(name, visitor) };
-                let prelude =
-                    { <Option<Box<AtRulePrelude>> as FoldWith<V>>::fold_with(prelude, visitor) };
-                let block = { <Option<SimpleBlock> as FoldWith<V>>::fold_with(block, visitor) };
-                AtRule {
-                    span,
-                    name,
-                    prelude,
-                    block,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Name));
+                    <AtRuleName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Prelude));
+                    <Option<Box<AtRulePrelude>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Block));
+                    <Option<SimpleBlock> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AtRuleName {
-    #[doc = "Calls [Fold`::fold_at_rule_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_at_rule_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AtRuleName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_at_rule_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_at_rule_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AtRuleName::DashedIdent { 0: _field_0 } => {
-                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRuleName::DashedIdent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
+                    self::fields::AtRuleNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRuleName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRuleName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
+                    self::fields::AtRuleNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AtRulePrelude {
-    #[doc = "Calls [Fold`::fold_at_rule_prelude`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_at_rule_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AtRulePrelude {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_at_rule_prelude`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_at_rule_prelude(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AtRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ListOfComponentValues,
+                ));
+                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::CharsetPrelude { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::CharsetPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::CharsetPrelude,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::PropertyPrelude { 0: _field_0 } => {
-                let _field_0 = <CustomPropertyName as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::PropertyPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::PropertyPrelude,
+                ));
+                <CustomPropertyName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::CounterStylePrelude { 0: _field_0 } => {
-                let _field_0 = <CustomIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::CounterStylePrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::CounterStylePrelude,
+                ));
+                <CustomIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ColorProfilePrelude { 0: _field_0 } => {
-                let _field_0 = <ColorProfileName as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::ColorProfilePrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ColorProfilePrelude,
+                ));
+                <ColorProfileName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::DocumentPrelude { 0: _field_0 } => {
-                let _field_0 = <DocumentPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::DocumentPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::DocumentPrelude,
+                ));
+                <DocumentPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 } => {
-                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::FontPaletteValuesPrelude,
+                ));
+                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 } => {
-                let _field_0 =
-                    <FontFeatureValuesPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::FontFeatureValuesPrelude,
+                ));
+                <FontFeatureValuesPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::NestPrelude { 0: _field_0 } => {
-                let _field_0 = <SelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::NestPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::NestPrelude,
+                ));
+                <SelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::KeyframesPrelude { 0: _field_0 } => {
-                let _field_0 = <KeyframesName as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::KeyframesPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::KeyframesPrelude,
+                ));
+                <KeyframesName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ImportPrelude { 0: _field_0 } => {
-                let _field_0 = <ImportPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::ImportPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ImportPrelude,
+                ));
+                <ImportPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::NamespacePrelude { 0: _field_0 } => {
-                let _field_0 = <NamespacePrelude as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::NamespacePrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::NamespacePrelude,
+                ));
+                <NamespacePrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::MediaPrelude { 0: _field_0 } => {
-                let _field_0 = <MediaQueryList as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::MediaPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::MediaPrelude,
+                ));
+                <MediaQueryList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::SupportsPrelude { 0: _field_0 } => {
-                let _field_0 = <SupportsCondition as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::SupportsPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::SupportsPrelude,
+                ));
+                <SupportsCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::PagePrelude { 0: _field_0 } => {
-                let _field_0 = <PageSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::PagePrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::PagePrelude,
+                ));
+                <PageSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::LayerPrelude { 0: _field_0 } => {
-                let _field_0 = <LayerPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::LayerPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::LayerPrelude,
+                ));
+                <LayerPrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
-                let _field_0 = <ContainerCondition as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::ContainerPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ContainerPrelude,
+                ));
+                <ContainerCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::CustomMediaPrelude { 0: _field_0 } => {
-                let _field_0 = <CustomMediaQuery as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::CustomMediaPrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::CustomMediaPrelude,
+                ));
+                <CustomMediaQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AtRulePrelude::ScopePrelude { 0: _field_0 } => {
-                let _field_0 = <ScopeRange as FoldWith<V>>::fold_with(_field_0, visitor);
-                AtRulePrelude::ScopePrelude { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ScopePrelude,
+                ));
+                <ScopeRange as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelector {
-    #[doc = "Calls [Fold`::fold_attribute_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_attribute_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AttributeSelector {
                 span,
@@ -82641,548 +63672,1060 @@ impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelector {
                 value,
                 modifier,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <WqName as FoldWith<V>>::fold_with(name, visitor) };
-                let matcher = {
-                    <Option<AttributeSelectorMatcher> as FoldWith<V>>::fold_with(matcher, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let value =
-                    { <Option<AttributeSelectorValue> as FoldWith<V>>::fold_with(value, visitor) };
-                let modifier = {
-                    <Option<AttributeSelectorModifier> as FoldWith<V>>::fold_with(modifier, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Name,
+                    ));
+                    <WqName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Matcher,
+                    ));
+                    < Option < AttributeSelectorMatcher > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (matcher , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Value,
+                    ));
+                    < Option < AttributeSelectorValue > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (value , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Modifier,
+                    ));
+                    < Option < AttributeSelectorModifier > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (modifier , visitor , & mut * __ast_path)
                 };
-                AttributeSelector {
-                    span,
-                    name,
-                    matcher,
-                    value,
-                    modifier,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorMatcher {
-    #[doc = "Calls [Fold`::fold_attribute_selector_matcher`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_attribute_selector_matcher(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorMatcher {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_matcher`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AttributeSelectorMatcher { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value =
-                    { <AttributeSelectorMatcherValue as FoldWith<V>>::fold_with(value, visitor) };
-                AttributeSelectorMatcher { span, value }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
+                            self::fields::AttributeSelectorMatcherField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
+                            self::fields::AttributeSelectorMatcherField::Value,
+                        ));
+                    < AttributeSelectorMatcherValue as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (value , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorMatcherValue {
-    #[doc = "Calls [Fold`::fold_attribute_selector_matcher_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_attribute_selector_matcher_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorMatcherValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_matcher_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_matcher_value(
+            visitor, self, __ast_path,
+        )
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            AttributeSelectorMatcherValue::Equals => AttributeSelectorMatcherValue::Equals,
-            AttributeSelectorMatcherValue::Tilde => AttributeSelectorMatcherValue::Tilde,
-            AttributeSelectorMatcherValue::Bar => AttributeSelectorMatcherValue::Bar,
-            AttributeSelectorMatcherValue::Caret => AttributeSelectorMatcherValue::Caret,
-            AttributeSelectorMatcherValue::Dollar => AttributeSelectorMatcherValue::Dollar,
-            AttributeSelectorMatcherValue::Asterisk => AttributeSelectorMatcherValue::Asterisk,
+            AttributeSelectorMatcherValue::Equals => {}
+            AttributeSelectorMatcherValue::Tilde => {}
+            AttributeSelectorMatcherValue::Bar => {}
+            AttributeSelectorMatcherValue::Caret => {}
+            AttributeSelectorMatcherValue::Dollar => {}
+            AttributeSelectorMatcherValue::Asterisk => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorModifier {
-    #[doc = "Calls [Fold`::fold_attribute_selector_modifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_attribute_selector_modifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorModifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_modifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_modifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AttributeSelectorModifier { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
-                AttributeSelectorModifier { span, value }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
+                            self::fields::AttributeSelectorModifierField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
+                            self::fields::AttributeSelectorModifierField::Value,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorValue {
-    #[doc = "Calls [Fold`::fold_attribute_selector_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_attribute_selector_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AttributeSelectorValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_selector_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_attribute_selector_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AttributeSelectorValue::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                AttributeSelectorValue::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
+                    self::fields::AttributeSelectorValueField::Str,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AttributeSelectorValue::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                AttributeSelectorValue::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
+                    self::fields::AttributeSelectorValueField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BinOp {
-    #[doc = "Calls [Fold`::fold_bin_op`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_bin_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinOp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_bin_op`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bin_op(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        match self {
-            BinOp::Add => BinOp::Add,
-            BinOp::Sub => BinOp::Sub,
-            BinOp::Mul => BinOp::Mul,
-            BinOp::Div => BinOp::Div,
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            BinOp::Add => {}
+            BinOp::Sub => {}
+            BinOp::Mul => {}
+            BinOp::Div => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CalcOperator {
-    #[doc = "Calls [Fold`::fold_calc_operator`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcOperator {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_operator`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_operator(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CalcOperator { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <CalcOperatorType as FoldWith<V>>::fold_with(value, visitor) };
-                CalcOperator { span, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
+                        self::fields::CalcOperatorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
+                        self::fields::CalcOperatorField::Value,
+                    ));
+                    <CalcOperatorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CalcOperatorType {
-    #[doc = "Calls [Fold`::fold_calc_operator_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_operator_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcOperatorType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_operator_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_operator_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            CalcOperatorType::Add => CalcOperatorType::Add,
-            CalcOperatorType::Sub => CalcOperatorType::Sub,
-            CalcOperatorType::Mul => CalcOperatorType::Mul,
-            CalcOperatorType::Div => CalcOperatorType::Div,
+            CalcOperatorType::Add => {}
+            CalcOperatorType::Sub => {}
+            CalcOperatorType::Mul => {}
+            CalcOperatorType::Div => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CalcProduct {
-    #[doc = "Calls [Fold`::fold_calc_product`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_product(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcProduct {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_product`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_product(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CalcProduct { span, expressions } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expressions =
-                    { <Vec<CalcValueOrOperator> as FoldWith<V>>::fold_with(expressions, visitor) };
-                CalcProduct { span, expressions }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
+                        self::fields::CalcProductField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
+                        self::fields::CalcProductField::Expressions(usize::MAX),
+                    ));
+                    <Vec<CalcValueOrOperator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expressions,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CalcProductOrOperator {
-    #[doc = "Calls [Fold`::fold_calc_product_or_operator`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_product_or_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcProductOrOperator {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_product_or_operator`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_product_or_operator(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CalcProductOrOperator::Product { 0: _field_0 } => {
-                let _field_0 = <CalcProduct as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcProductOrOperator::Product { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
+                    self::fields::CalcProductOrOperatorField::Product,
+                ));
+                <CalcProduct as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcProductOrOperator::Operator { 0: _field_0 } => {
-                let _field_0 = <CalcOperator as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcProductOrOperator::Operator { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
+                    self::fields::CalcProductOrOperatorField::Operator,
+                ));
+                <CalcOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CalcSum {
-    #[doc = "Calls [Fold`::fold_calc_sum`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_sum(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcSum {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_sum`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_sum(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CalcSum { span, expressions } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expressions = {
-                    <Vec<CalcProductOrOperator> as FoldWith<V>>::fold_with(expressions, visitor)
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CalcSum(self::fields::CalcSumField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcSum(
+                        self::fields::CalcSumField::Expressions(usize::MAX),
+                    ));
+                    <Vec<CalcProductOrOperator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expressions,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                CalcSum { span, expressions }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CalcValue {
-    #[doc = "Calls [Fold`::fold_calc_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CalcValue::Number { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValue::Number { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Number,
+                ));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Dimension { 0: _field_0 } => {
-                let _field_0 = <Dimension as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValue::Dimension { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Dimension,
+                ));
+                <Dimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValue::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Constant { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValue::Constant { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Constant,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Sum { 0: _field_0 } => {
-                let _field_0 = <CalcSum as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValue::Sum { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::CalcValue(self::fields::CalcValueField::Sum));
+                <CalcSum as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValue::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValue::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CalcValueOrOperator {
-    #[doc = "Calls [Fold`::fold_calc_value_or_operator`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_value_or_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CalcValueOrOperator {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_value_or_operator`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_value_or_operator(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CalcValueOrOperator::Value { 0: _field_0 } => {
-                let _field_0 = <CalcValue as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValueOrOperator::Value { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
+                    self::fields::CalcValueOrOperatorField::Value,
+                ));
+                <CalcValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CalcValueOrOperator::Operator { 0: _field_0 } => {
-                let _field_0 = <CalcOperator as FoldWith<V>>::fold_with(_field_0, visitor);
-                CalcValueOrOperator::Operator { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
+                    self::fields::CalcValueOrOperatorField::Operator,
+                ));
+                <CalcOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ClassSelector {
-    #[doc = "Calls [Fold`::fold_class_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ClassSelector { span, text } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let text = { <Ident as FoldWith<V>>::fold_with(text, visitor) };
-                ClassSelector { span, text }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
+                        self::fields::ClassSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
+                        self::fields::ClassSelectorField::Text,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        text,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CmykComponent {
-    #[doc = "Calls [Fold`::fold_cmyk_component`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_cmyk_component(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CmykComponent {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_cmyk_component`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_cmyk_component(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CmykComponent::Number { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                CmykComponent::Number { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
+                    self::fields::CmykComponentField::Number,
+                ));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CmykComponent::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                CmykComponent::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
+                    self::fields::CmykComponentField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CmykComponent::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                CmykComponent::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
+                    self::fields::CmykComponentField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Color {
-    #[doc = "Calls [Fold`::fold_color`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_color(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Color {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_color`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_color(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Color::AbsoluteColorBase { 0: _field_0 } => {
-                let _field_0 = <AbsoluteColorBase as FoldWith<V>>::fold_with(_field_0, visitor);
-                Color::AbsoluteColorBase { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
+                    self::fields::ColorField::AbsoluteColorBase,
+                ));
+                <AbsoluteColorBase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Color::CurrentColorOrSystemColor { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                Color::CurrentColorOrSystemColor { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
+                    self::fields::ColorField::CurrentColorOrSystemColor,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Color::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                Color::Function { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Color(self::fields::ColorField::Function));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ColorProfileName {
-    #[doc = "Calls [Fold`::fold_color_profile_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_color_profile_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ColorProfileName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_color_profile_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_color_profile_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ColorProfileName::DashedIdent { 0: _field_0 } => {
-                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                ColorProfileName::DashedIdent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
+                    self::fields::ColorProfileNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ColorProfileName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                ColorProfileName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
+                    self::fields::ColorProfileNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Combinator {
-    #[doc = "Calls [Fold`::fold_combinator`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_combinator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Combinator {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_combinator`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_combinator(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Combinator { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <CombinatorValue as FoldWith<V>>::fold_with(value, visitor) };
-                Combinator { span, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
+                        self::fields::CombinatorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
+                        self::fields::CombinatorField::Value,
+                    ));
+                    <CombinatorValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CombinatorValue {
-    #[doc = "Calls [Fold`::fold_combinator_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_combinator_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CombinatorValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_combinator_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_combinator_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            CombinatorValue::Descendant => CombinatorValue::Descendant,
-            CombinatorValue::NextSibling => CombinatorValue::NextSibling,
-            CombinatorValue::Child => CombinatorValue::Child,
-            CombinatorValue::LaterSibling => CombinatorValue::LaterSibling,
-            CombinatorValue::Column => CombinatorValue::Column,
+            CombinatorValue::Descendant => {}
+            CombinatorValue::NextSibling => {}
+            CombinatorValue::Child => {}
+            CombinatorValue::LaterSibling => {}
+            CombinatorValue::Column => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ComplexSelector {
-    #[doc = "Calls [Fold`::fold_complex_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_complex_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComplexSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ComplexSelector { span, children } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let children =
-                    { <Vec<ComplexSelectorChildren> as FoldWith<V>>::fold_with(children, visitor) };
-                ComplexSelector { span, children }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
+                        self::fields::ComplexSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
+                        self::fields::ComplexSelectorField::Children(usize::MAX),
+                    ));
+                    < Vec < ComplexSelectorChildren > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ComplexSelectorChildren {
-    #[doc = "Calls [Fold`::fold_complex_selector_children`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_complex_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComplexSelectorChildren {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selector_children`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector_children(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ComplexSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let _field_0 = <CompoundSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComplexSelectorChildren::CompoundSelector { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
+                    self::fields::ComplexSelectorChildrenField::CompoundSelector,
+                ));
+                <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComplexSelectorChildren::Combinator { 0: _field_0 } => {
-                let _field_0 = <Combinator as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComplexSelectorChildren::Combinator { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
+                    self::fields::ComplexSelectorChildrenField::Combinator,
+                ));
+                <Combinator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ComponentValue {
-    #[doc = "Calls [Fold`::fold_component_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_component_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComponentValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_component_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_component_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ComponentValue::PreservedToken { 0: _field_0 } => {
-                let _field_0 = <Box<TokenAndSpan> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::PreservedToken { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::PreservedToken,
+                ));
+                <Box<TokenAndSpan> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Function { 0: _field_0 } => {
-                let _field_0 = <Box<Function> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Function,
+                ));
+                <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::SimpleBlock { 0: _field_0 } => {
-                let _field_0 = <Box<SimpleBlock> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::SimpleBlock { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::SimpleBlock,
+                ));
+                <Box<SimpleBlock> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::AtRule { 0: _field_0 } => {
-                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::AtRule { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::AtRule,
+                ));
+                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::QualifiedRule { 0: _field_0 } => {
-                let _field_0 = <Box<QualifiedRule> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::QualifiedRule { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::QualifiedRule,
+                ));
+                <Box<QualifiedRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::KeyframeBlock { 0: _field_0 } => {
-                let _field_0 = <Box<KeyframeBlock> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::KeyframeBlock { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::KeyframeBlock,
+                ));
+                <Box<KeyframeBlock> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Ident { 0: _field_0 } => {
-                let _field_0 = <Box<Ident> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Ident,
+                ));
+                <Box<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::DashedIdent { 0: _field_0 } => {
-                let _field_0 = <Box<DashedIdent> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::DashedIdent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::DashedIdent,
+                ));
+                <Box<DashedIdent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Str { 0: _field_0 } => {
-                let _field_0 = <Box<Str> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Str,
+                ));
+                <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Url { 0: _field_0 } => {
-                let _field_0 = <Box<Url> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Url { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Url,
+                ));
+                <Box<Url> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Integer { 0: _field_0 } => {
-                let _field_0 = <Box<Integer> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Integer { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Integer,
+                ));
+                <Box<Integer> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Number { 0: _field_0 } => {
-                let _field_0 = <Box<Number> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Number { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Number,
+                ));
+                <Box<Number> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Percentage { 0: _field_0 } => {
-                let _field_0 = <Box<Percentage> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Percentage,
+                ));
+                <Box<Percentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Dimension { 0: _field_0 } => {
-                let _field_0 = <Box<Dimension> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Dimension { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Dimension,
+                ));
+                <Box<Dimension> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::LengthPercentage { 0: _field_0 } => {
-                let _field_0 = <Box<LengthPercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::LengthPercentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::LengthPercentage,
+                ));
+                <Box<LengthPercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::FrequencyPercentage { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<FrequencyPercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::FrequencyPercentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::FrequencyPercentage,
+                ));
+                <Box<FrequencyPercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::AnglePercentage { 0: _field_0 } => {
-                let _field_0 = <Box<AnglePercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::AnglePercentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::AnglePercentage,
+                ));
+                <Box<AnglePercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::TimePercentage { 0: _field_0 } => {
-                let _field_0 = <Box<TimePercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::TimePercentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::TimePercentage,
+                ));
+                <Box<TimePercentage> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Ratio { 0: _field_0 } => {
-                let _field_0 = <Box<Ratio> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Ratio { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Ratio,
+                ));
+                <Box<Ratio> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::UnicodeRange { 0: _field_0 } => {
-                let _field_0 = <Box<UnicodeRange> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::UnicodeRange { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::UnicodeRange,
+                ));
+                <Box<UnicodeRange> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Color { 0: _field_0 } => {
-                let _field_0 = <Box<Color> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Color { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Color,
+                ));
+                <Box<Color> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::AlphaValue { 0: _field_0 } => {
-                let _field_0 = <Box<AlphaValue> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::AlphaValue { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::AlphaValue,
+                ));
+                <Box<AlphaValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Hue { 0: _field_0 } => {
-                let _field_0 = <Box<Hue> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Hue { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Hue,
+                ));
+                <Box<Hue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::CmykComponent { 0: _field_0 } => {
-                let _field_0 = <Box<CmykComponent> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::CmykComponent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::CmykComponent,
+                ));
+                <Box<CmykComponent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Delimiter { 0: _field_0 } => {
-                let _field_0 = <Box<Delimiter> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Delimiter { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Delimiter,
+                ));
+                <Box<Delimiter> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::CalcSum { 0: _field_0 } => {
-                let _field_0 = <Box<CalcSum> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::CalcSum { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::CalcSum,
+                ));
+                <Box<CalcSum> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::ComplexSelector { 0: _field_0 } => {
-                let _field_0 = <Box<ComplexSelector> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::ComplexSelector { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::ComplexSelector,
+                ));
+                <Box<ComplexSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::LayerName { 0: _field_0 } => {
-                let _field_0 = <Box<LayerName> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::LayerName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::LayerName,
+                ));
+                <Box<LayerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::SupportsCondition { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<SupportsCondition> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::SupportsCondition { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::SupportsCondition,
+                ));
+                <Box<SupportsCondition> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::Declaration { 0: _field_0 } => {
-                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::Declaration { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Declaration,
+                ));
+                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ComponentValue::IdSelector { 0: _field_0 } => {
-                let _field_0 = <Box<IdSelector> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ComponentValue::IdSelector { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::IdSelector,
+                ));
+                <Box<IdSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CompoundSelector {
-    #[doc = "Calls [Fold`::fold_compound_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_compound_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CompoundSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_compound_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_compound_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CompoundSelector {
                 span,
@@ -83190,306 +64733,659 @@ impl<V: ?Sized + Fold> FoldWith<V> for CompoundSelector {
                 type_selector,
                 subclass_selectors,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let nesting_selector = {
-                    <Option<NestingSelector> as FoldWith<V>>::fold_with(nesting_selector, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let type_selector = {
-                    <Option<Box<TypeSelector>> as FoldWith<V>>::fold_with(type_selector, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::NestingSelector,
+                    ));
+                    <Option<NestingSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        nesting_selector,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let subclass_selectors = {
-                    <Vec<SubclassSelector> as FoldWith<V>>::fold_with(subclass_selectors, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::TypeSelector,
+                    ));
+                    <Option<Box<TypeSelector>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_selector,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::SubclassSelectors(usize::MAX),
+                    ));
+                    <Vec<SubclassSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        subclass_selectors,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                CompoundSelector {
-                    span,
-                    nesting_selector,
-                    type_selector,
-                    subclass_selectors,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CompoundSelectorList {
-    #[doc = "Calls [Fold`::fold_compound_selector_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_compound_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CompoundSelectorList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_compound_selector_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_compound_selector_list(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CompoundSelectorList { span, children } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let children =
-                    { <Vec<CompoundSelector> as FoldWith<V>>::fold_with(children, visitor) };
-                CompoundSelectorList { span, children }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
+                            self::fields::CompoundSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
+                            self::fields::CompoundSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<CompoundSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ContainerCondition {
-    #[doc = "Calls [Fold`::fold_container_condition`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerCondition {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_condition`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_condition(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContainerCondition { span, name, query } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Option<ContainerName> as FoldWith<V>>::fold_with(name, visitor) };
-                let query = { <ContainerQuery as FoldWith<V>>::fold_with(query, visitor) };
-                ContainerCondition { span, name, query }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
+                        self::fields::ContainerConditionField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
+                        self::fields::ContainerConditionField::Name,
+                    ));
+                    <Option<ContainerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
+                        self::fields::ContainerConditionField::Query,
+                    ));
+                    <ContainerQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
-}
-impl<V: ?Sized + Fold> FoldWith<V> for ContainerName {
-    #[doc = "Calls [Fold`::fold_container_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_name(visitor, self)
-    }
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_name(visitor, self, __ast_path)
+    }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContainerName::CustomIdent { 0: _field_0 } => {
-                let _field_0 = <CustomIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                ContainerName::CustomIdent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerName(
+                    self::fields::ContainerNameField::CustomIdent,
+                ));
+                <CustomIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ContainerQuery {
-    #[doc = "Calls [Fold`::fold_container_query`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQuery {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_query(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContainerQuery { span, queries } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let queries =
-                    { <Vec<ContainerQueryType> as FoldWith<V>>::fold_with(queries, visitor) };
-                ContainerQuery { span, queries }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
+                        self::fields::ContainerQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
+                        self::fields::ContainerQueryField::Queries(usize::MAX),
+                    ));
+                    <Vec<ContainerQueryType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        queries,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryAnd {
-    #[doc = "Calls [Fold`::fold_container_query_and`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_query_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryAnd {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_and`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_query_and(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContainerQueryAnd {
                 span,
                 keyword,
                 query,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let query = { <QueryInParens as FoldWith<V>>::fold_with(query, visitor) };
-                ContainerQueryAnd {
-                    span,
-                    keyword,
-                    query,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
+                        self::fields::ContainerQueryAndField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
+                        self::fields::ContainerQueryAndField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
+                        self::fields::ContainerQueryAndField::Query,
+                    ));
+                    <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryNot {
-    #[doc = "Calls [Fold`::fold_container_query_not`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_query_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryNot {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_not`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_query_not(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContainerQueryNot {
                 span,
                 keyword,
                 query,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let query = { <QueryInParens as FoldWith<V>>::fold_with(query, visitor) };
-                ContainerQueryNot {
-                    span,
-                    keyword,
-                    query,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
+                        self::fields::ContainerQueryNotField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
+                        self::fields::ContainerQueryNotField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
+                        self::fields::ContainerQueryNotField::Query,
+                    ));
+                    <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryOr {
-    #[doc = "Calls [Fold`::fold_container_query_or`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_query_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryOr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_or`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_query_or(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContainerQueryOr {
                 span,
                 keyword,
                 query,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let query = { <QueryInParens as FoldWith<V>>::fold_with(query, visitor) };
-                ContainerQueryOr {
-                    span,
-                    keyword,
-                    query,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
+                        self::fields::ContainerQueryOrField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
+                        self::fields::ContainerQueryOrField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
+                        self::fields::ContainerQueryOrField::Query,
+                    ));
+                    <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryType {
-    #[doc = "Calls [Fold`::fold_container_query_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_query_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContainerQueryType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_query_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContainerQueryType::Not { 0: _field_0 } => {
-                let _field_0 = <ContainerQueryNot as FoldWith<V>>::fold_with(_field_0, visitor);
-                ContainerQueryType::Not { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::Not,
+                ));
+                <ContainerQueryNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ContainerQueryType::And { 0: _field_0 } => {
-                let _field_0 = <ContainerQueryAnd as FoldWith<V>>::fold_with(_field_0, visitor);
-                ContainerQueryType::And { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::And,
+                ));
+                <ContainerQueryAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ContainerQueryType::Or { 0: _field_0 } => {
-                let _field_0 = <ContainerQueryOr as FoldWith<V>>::fold_with(_field_0, visitor);
-                ContainerQueryType::Or { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::Or,
+                ));
+                <ContainerQueryOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ContainerQueryType::QueryInParens { 0: _field_0 } => {
-                let _field_0 = <QueryInParens as FoldWith<V>>::fold_with(_field_0, visitor);
-                ContainerQueryType::QueryInParens { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::QueryInParens,
+                ));
+                <QueryInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CustomHighlightName {
-    #[doc = "Calls [Fold`::fold_custom_highlight_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_custom_highlight_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomHighlightName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_highlight_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_highlight_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CustomHighlightName { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                CustomHighlightName { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
+                        self::fields::CustomHighlightNameField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
+                        self::fields::CustomHighlightNameField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
+                        self::fields::CustomHighlightNameField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CustomIdent {
-    #[doc = "Calls [Fold`::fold_custom_ident`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_custom_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomIdent {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_ident`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_ident(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CustomIdent { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                CustomIdent { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
+                        self::fields::CustomIdentField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
+                        self::fields::CustomIdentField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
+                        self::fields::CustomIdentField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CustomMediaQuery {
-    #[doc = "Calls [Fold`::fold_custom_media_query`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_custom_media_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomMediaQuery {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_media_query`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_media_query(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CustomMediaQuery { span, name, media } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <ExtensionName as FoldWith<V>>::fold_with(name, visitor) };
-                let media =
-                    { <CustomMediaQueryMediaType as FoldWith<V>>::fold_with(media, visitor) };
-                CustomMediaQuery { span, name, media }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
+                        self::fields::CustomMediaQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
+                        self::fields::CustomMediaQueryField::Name,
+                    ));
+                    <ExtensionName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
+                        self::fields::CustomMediaQueryField::Media,
+                    ));
+                    <CustomMediaQueryMediaType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        media,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CustomMediaQueryMediaType {
-    #[doc = "Calls [Fold`::fold_custom_media_query_media_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_custom_media_query_media_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomMediaQueryMediaType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_media_query_media_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_media_query_media_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CustomMediaQueryMediaType::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                CustomMediaQueryMediaType::Ident { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
+                        self::fields::CustomMediaQueryMediaTypeField::Ident,
+                    ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 } => {
-                let _field_0 = <MediaQueryList as FoldWith<V>>::fold_with(_field_0, visitor);
-                CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
+                        self::fields::CustomMediaQueryMediaTypeField::MediaQueryList,
+                    ));
+                <MediaQueryList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CustomPropertyName {
-    #[doc = "Calls [Fold`::fold_custom_property_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_custom_property_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CustomPropertyName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_property_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_property_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CustomPropertyName { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                CustomPropertyName { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
+                        self::fields::CustomPropertyNameField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
+                        self::fields::CustomPropertyNameField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
+                        self::fields::CustomPropertyNameField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DashedIdent {
-    #[doc = "Calls [Fold`::fold_dashed_ident`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_dashed_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DashedIdent {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_dashed_ident`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_dashed_ident(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DashedIdent { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                DashedIdent { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
+                        self::fields::DashedIdentField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
+                        self::fields::DashedIdentField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
+                        self::fields::DashedIdentField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Declaration {
-    #[doc = "Calls [Fold`::fold_declaration`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_declaration(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Declaration {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_declaration`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_declaration(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Declaration {
                 span,
@@ -83497,140 +65393,266 @@ impl<V: ?Sized + Fold> FoldWith<V> for Declaration {
                 value,
                 important,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <DeclarationName as FoldWith<V>>::fold_with(name, visitor) };
-                let value = { <Vec<ComponentValue> as FoldWith<V>>::fold_with(value, visitor) };
-                let important =
-                    { <Option<ImportantFlag> as FoldWith<V>>::fold_with(important, visitor) };
-                Declaration {
-                    span,
-                    name,
-                    value,
-                    important,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Name,
+                    ));
+                    <DeclarationName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Important,
+                    ));
+                    <Option<ImportantFlag> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        important,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DeclarationName {
-    #[doc = "Calls [Fold`::fold_declaration_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_declaration_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DeclarationName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_declaration_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_declaration_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DeclarationName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                DeclarationName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
+                    self::fields::DeclarationNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DeclarationName::DashedIdent { 0: _field_0 } => {
-                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                DeclarationName::DashedIdent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
+                    self::fields::DeclarationNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DeclarationOrAtRule {
-    #[doc = "Calls [Fold`::fold_declaration_or_at_rule`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_declaration_or_at_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DeclarationOrAtRule {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_declaration_or_at_rule`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_declaration_or_at_rule(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DeclarationOrAtRule::Declaration { 0: _field_0 } => {
-                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
-                DeclarationOrAtRule::Declaration { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
+                    self::fields::DeclarationOrAtRuleField::Declaration,
+                ));
+                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DeclarationOrAtRule::AtRule { 0: _field_0 } => {
-                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
-                DeclarationOrAtRule::AtRule { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
+                    self::fields::DeclarationOrAtRuleField::AtRule,
+                ));
+                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
-                DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
+                    self::fields::DeclarationOrAtRuleField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Delimiter {
-    #[doc = "Calls [Fold`::fold_delimiter`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_delimiter(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Delimiter {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_delimiter`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_delimiter(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Delimiter { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <DelimiterValue as FoldWith<V>>::fold_with(value, visitor) };
-                Delimiter { span, value }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Delimiter(self::fields::DelimiterField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Delimiter(
+                        self::fields::DelimiterField::Value,
+                    ));
+                    <DelimiterValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DelimiterValue {
-    #[doc = "Calls [Fold`::fold_delimiter_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_delimiter_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DelimiterValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_delimiter_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_delimiter_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            DelimiterValue::Comma => DelimiterValue::Comma,
-            DelimiterValue::Solidus => DelimiterValue::Solidus,
-            DelimiterValue::Semicolon => DelimiterValue::Semicolon,
+            DelimiterValue::Comma => {}
+            DelimiterValue::Solidus => {}
+            DelimiterValue::Semicolon => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Dimension {
-    #[doc = "Calls [Fold`::fold_dimension`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_dimension(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Dimension {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_dimension`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_dimension(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Dimension::Length { 0: _field_0 } => {
-                let _field_0 = <Length as FoldWith<V>>::fold_with(_field_0, visitor);
-                Dimension::Length { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Length,
+                ));
+                <Length as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Angle { 0: _field_0 } => {
-                let _field_0 = <Angle as FoldWith<V>>::fold_with(_field_0, visitor);
-                Dimension::Angle { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Angle,
+                ));
+                <Angle as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Time { 0: _field_0 } => {
-                let _field_0 = <Time as FoldWith<V>>::fold_with(_field_0, visitor);
-                Dimension::Time { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Time));
+                <Time as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Frequency { 0: _field_0 } => {
-                let _field_0 = <Frequency as FoldWith<V>>::fold_with(_field_0, visitor);
-                Dimension::Frequency { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Frequency,
+                ));
+                <Frequency as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Resolution { 0: _field_0 } => {
-                let _field_0 = <Resolution as FoldWith<V>>::fold_with(_field_0, visitor);
-                Dimension::Resolution { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Resolution,
+                ));
+                <Resolution as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::Flex { 0: _field_0 } => {
-                let _field_0 = <Flex as FoldWith<V>>::fold_with(_field_0, visitor);
-                Dimension::Flex { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Flex));
+                <Flex as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Dimension::UnknownDimension { 0: _field_0 } => {
-                let _field_0 = <UnknownDimension as FoldWith<V>>::fold_with(_field_0, visitor);
-                Dimension::UnknownDimension { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::UnknownDimension,
+                ));
+                <UnknownDimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DimensionToken {
-    #[doc = "Calls [Fold`::fold_dimension_token`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_dimension_token(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DimensionToken {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_dimension_token`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_dimension_token(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DimensionToken {
                 value,
@@ -83639,444 +65661,875 @@ impl<V: ?Sized + Fold> FoldWith<V> for DimensionToken {
                 type_flag,
                 raw_unit,
             } => {
-                let raw_value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw_value, visitor) };
-                let unit = { <swc_atoms::Atom as FoldWith<V>>::fold_with(unit, visitor) };
-                let type_flag = { <NumberType as FoldWith<V>>::fold_with(type_flag, visitor) };
-                let raw_unit = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw_unit, visitor) };
-                DimensionToken {
-                    value,
-                    raw_value,
-                    unit,
-                    type_flag,
-                    raw_unit,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::RawValue,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw_value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::Unit,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::TypeFlag,
+                    ));
+                    <NumberType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_flag,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::RawUnit,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw_unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DocumentPrelude {
-    #[doc = "Calls [Fold`::fold_document_prelude`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_document_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DocumentPrelude {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_document_prelude`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DocumentPrelude {
                 span,
                 matching_functions,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let matching_functions = {
-                    <Vec<DocumentPreludeMatchingFunction> as FoldWith<V>>::fold_with(
-                        matching_functions,
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
+                        self::fields::DocumentPreludeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                DocumentPrelude {
-                    span,
-                    matching_functions,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
+                        self::fields::DocumentPreludeField::MatchingFunctions(usize::MAX),
+                    ));
+                    < Vec < DocumentPreludeMatchingFunction > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (matching_functions , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DocumentPreludeMatchingFunction {
-    #[doc = "Calls [Fold`::fold_document_prelude_matching_function`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_document_prelude_matching_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DocumentPreludeMatchingFunction {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_document_prelude_matching_function`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_function(
+            visitor, self, __ast_path,
+        )
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DocumentPreludeMatchingFunction::Url { 0: _field_0 } => {
-                let _field_0 = <Url as FoldWith<V>>::fold_with(_field_0, visitor);
-                DocumentPreludeMatchingFunction::Url { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
+                        self::fields::DocumentPreludeMatchingFunctionField::Url,
+                    ));
+                <Url as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DocumentPreludeMatchingFunction::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                DocumentPreludeMatchingFunction::Function { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
+                        self::fields::DocumentPreludeMatchingFunctionField::Function,
+                    ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExtensionName {
-    #[doc = "Calls [Fold`::fold_extension_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_extension_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExtensionName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_extension_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_extension_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExtensionName { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                ExtensionName { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
+                        self::fields::ExtensionNameField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
+                        self::fields::ExtensionNameField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
+                        self::fields::ExtensionNameField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for FamilyName {
-    #[doc = "Calls [Fold`::fold_family_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_family_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FamilyName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_family_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_family_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             FamilyName::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                FamilyName::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
+                    self::fields::FamilyNameField::Str,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             FamilyName::SequenceOfCustomIdents { 0: _field_0 } => {
-                let _field_0 =
-                    <SequenceOfCustomIdents as FoldWith<V>>::fold_with(_field_0, visitor);
-                FamilyName::SequenceOfCustomIdents { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
+                    self::fields::FamilyNameField::SequenceOfCustomIdents,
+                ));
+                <SequenceOfCustomIdents as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Flex {
-    #[doc = "Calls [Fold`::fold_flex`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_flex(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Flex {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_flex`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_flex(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Flex { span, value, unit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
-                Flex { span, value, unit }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Value));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Unit));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for FontFeatureValuesPrelude {
-    #[doc = "Calls [Fold`::fold_font_feature_values_prelude`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_font_feature_values_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FontFeatureValuesPrelude {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_font_feature_values_prelude`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_font_feature_values_prelude(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             FontFeatureValuesPrelude { span, font_family } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let font_family =
-                    { <Vec<FamilyName> as FoldWith<V>>::fold_with(font_family, visitor) };
-                FontFeatureValuesPrelude { span, font_family }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
+                            self::fields::FontFeatureValuesPreludeField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
+                            self::fields::FontFeatureValuesPreludeField::FontFamily(usize::MAX),
+                        ));
+                    <Vec<FamilyName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        font_family,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForgivingComplexSelector {
-    #[doc = "Calls [Fold`::fold_forgiving_complex_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_forgiving_complex_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingComplexSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_complex_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForgivingComplexSelector::ComplexSelector { 0: _field_0 } => {
-                let _field_0 = <ComplexSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                ForgivingComplexSelector::ComplexSelector { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
+                        self::fields::ForgivingComplexSelectorField::ComplexSelector,
+                    ));
+                <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
-                ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
+                        self::fields::ForgivingComplexSelectorField::ListOfComponentValues,
+                    ));
+                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForgivingRelativeSelector {
-    #[doc = "Calls [Fold`::fold_forgiving_relative_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_forgiving_relative_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingRelativeSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_relative_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForgivingRelativeSelector::RelativeSelector { 0: _field_0 } => {
-                let _field_0 = <RelativeSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                ForgivingRelativeSelector::RelativeSelector { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
+                        self::fields::ForgivingRelativeSelectorField::RelativeSelector,
+                    ));
+                <RelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
-                ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
+                        self::fields::ForgivingRelativeSelectorField::ListOfComponentValues,
+                    ));
+                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForgivingRelativeSelectorList {
-    #[doc = "Calls [Fold`::fold_forgiving_relative_selector_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_forgiving_relative_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingRelativeSelectorList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_relative_selector_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selector_list(
+            visitor, self, __ast_path,
+        )
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForgivingRelativeSelectorList { span, children } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let children = {
-                    <Vec<ForgivingRelativeSelector> as FoldWith<V>>::fold_with(children, visitor)
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
+                            self::fields::ForgivingRelativeSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
+                            self::fields::ForgivingRelativeSelectorListField::Children(usize::MAX),
+                        ));
+                    < Vec < ForgivingRelativeSelector > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
                 };
-                ForgivingRelativeSelectorList { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForgivingSelectorList {
-    #[doc = "Calls [Fold`::fold_forgiving_selector_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_forgiving_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForgivingSelectorList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_selector_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_selector_list(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForgivingSelectorList { span, children } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let children = {
-                    <Vec<ForgivingComplexSelector> as FoldWith<V>>::fold_with(children, visitor)
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
+                            self::fields::ForgivingSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
+                            self::fields::ForgivingSelectorListField::Children(usize::MAX),
+                        ));
+                    < Vec < ForgivingComplexSelector > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
                 };
-                ForgivingSelectorList { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Frequency {
-    #[doc = "Calls [Fold`::fold_frequency`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_frequency(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Frequency {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_frequency`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_frequency(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Frequency { span, value, unit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
-                Frequency { span, value, unit }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Frequency(
+                        self::fields::FrequencyField::Value,
+                    ));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Unit));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for FrequencyPercentage {
-    #[doc = "Calls [Fold`::fold_frequency_percentage`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_frequency_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FrequencyPercentage {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_frequency_percentage`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_frequency_percentage(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             FrequencyPercentage::Frequency { 0: _field_0 } => {
-                let _field_0 = <Frequency as FoldWith<V>>::fold_with(_field_0, visitor);
-                FrequencyPercentage::Frequency { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
+                    self::fields::FrequencyPercentageField::Frequency,
+                ));
+                <Frequency as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             FrequencyPercentage::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                FrequencyPercentage::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
+                    self::fields::FrequencyPercentageField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Function {
-    #[doc = "Calls [Fold`::fold_function`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Function {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_function`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Function { span, name, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <FunctionName as FoldWith<V>>::fold_with(name, visitor) };
-                let value = { <Vec<ComponentValue> as FoldWith<V>>::fold_with(value, visitor) };
-                Function { span, name, value }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Name));
+                    <FunctionName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for FunctionName {
-    #[doc = "Calls [Fold`::fold_function_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_function_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FunctionName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_function_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             FunctionName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                FunctionName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
+                    self::fields::FunctionNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             FunctionName::DashedIdent { 0: _field_0 } => {
-                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                FunctionName::DashedIdent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
+                    self::fields::FunctionNameField::DashedIdent,
+                ));
+                <DashedIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for GeneralEnclosed {
-    #[doc = "Calls [Fold`::fold_general_enclosed`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_general_enclosed(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for GeneralEnclosed {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_general_enclosed`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_general_enclosed(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             GeneralEnclosed::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                GeneralEnclosed::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
+                    self::fields::GeneralEnclosedField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             GeneralEnclosed::SimpleBlock { 0: _field_0 } => {
-                let _field_0 = <SimpleBlock as FoldWith<V>>::fold_with(_field_0, visitor);
-                GeneralEnclosed::SimpleBlock { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
+                    self::fields::GeneralEnclosedField::SimpleBlock,
+                ));
+                <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for HexColor {
-    #[doc = "Calls [Fold`::fold_hex_color`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_hex_color(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for HexColor {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_hex_color`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_hex_color(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             HexColor { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                HexColor { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Hue {
-    #[doc = "Calls [Fold`::fold_hue`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_hue(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Hue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_hue`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_hue(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Hue::Number { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                Hue::Number { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Number));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Hue::Angle { 0: _field_0 } => {
-                let _field_0 = <Angle as FoldWith<V>>::fold_with(_field_0, visitor);
-                Hue::Angle { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Angle));
+                <Angle as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for IdSelector {
-    #[doc = "Calls [Fold`::fold_id_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_id_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for IdSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_id_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_id_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             IdSelector { span, text } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let text = { <Ident as FoldWith<V>>::fold_with(text, visitor) };
-                IdSelector { span, text }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
+                        self::fields::IdSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
+                        self::fields::IdSelectorField::Text,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        text,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Ident {
-    #[doc = "Calls [Fold`::fold_ident`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Ident {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ident`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Ident { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                Ident { span, value, raw }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Ident(self::fields::IdentField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportConditions {
-    #[doc = "Calls [Fold`::fold_import_conditions`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_conditions(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportConditions {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_conditions`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_conditions(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportConditions {
                 span,
                 supports,
                 media,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let supports =
-                    { <Option<Box<Function>> as FoldWith<V>>::fold_with(supports, visitor) };
-                let media =
-                    { <Option<Box<MediaQueryList>> as FoldWith<V>>::fold_with(media, visitor) };
-                ImportConditions {
-                    span,
-                    supports,
-                    media,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
+                        self::fields::ImportConditionsField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
+                        self::fields::ImportConditionsField::Supports,
+                    ));
+                    <Option<Box<Function>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        supports,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
+                        self::fields::ImportConditionsField::Media,
+                    ));
+                    <Option<Box<MediaQueryList>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        media,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportHref {
-    #[doc = "Calls [Fold`::fold_import_href`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_href(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportHref {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_href`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_href(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportHref::Url { 0: _field_0 } => {
-                let _field_0 = <Url as FoldWith<V>>::fold_with(_field_0, visitor);
-                ImportHref::Url { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
+                    self::fields::ImportHrefField::Url,
+                ));
+                <Url as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportHref::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                ImportHref::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
+                    self::fields::ImportHrefField::Str,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportLayerName {
-    #[doc = "Calls [Fold`::fold_import_layer_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_layer_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportLayerName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_layer_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_layer_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportLayerName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                ImportLayerName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
+                    self::fields::ImportLayerNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportLayerName::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                ImportLayerName::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
+                    self::fields::ImportLayerNameField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportPrelude {
-    #[doc = "Calls [Fold`::fold_import_prelude`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportPrelude {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_prelude`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_prelude(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportPrelude {
                 span,
@@ -84084,490 +66537,978 @@ impl<V: ?Sized + Fold> FoldWith<V> for ImportPrelude {
                 layer_name,
                 import_conditions,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let href = { <Box<ImportHref> as FoldWith<V>>::fold_with(href, visitor) };
-                let layer_name = {
-                    <Option<Box<ImportLayerName>> as FoldWith<V>>::fold_with(layer_name, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let import_conditions = {
-                    <Option<Box<ImportConditions>> as FoldWith<V>>::fold_with(
-                        import_conditions,
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::Href,
+                    ));
+                    <Box<ImportHref> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        href,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                ImportPrelude {
-                    span,
-                    href,
-                    layer_name,
-                    import_conditions,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::LayerName,
+                    ));
+                    < Option < Box < ImportLayerName > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (layer_name , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::ImportConditions,
+                    ));
+                    < Option < Box < ImportConditions > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (import_conditions , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportantFlag {
-    #[doc = "Calls [Fold`::fold_important_flag`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_important_flag(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportantFlag {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_important_flag`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_important_flag(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportantFlag { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
-                ImportantFlag { span, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
+                        self::fields::ImportantFlagField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
+                        self::fields::ImportantFlagField::Value,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Integer {
-    #[doc = "Calls [Fold`::fold_integer`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_integer(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Integer {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_integer`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_integer(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Integer { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                Integer { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for KeyframeBlock {
-    #[doc = "Calls [Fold`::fold_keyframe_block`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_keyframe_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframeBlock {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframe_block`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_block(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             KeyframeBlock {
                 span,
                 prelude,
                 block,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let prelude =
-                    { <Vec<KeyframeSelector> as FoldWith<V>>::fold_with(prelude, visitor) };
-                let block = { <SimpleBlock as FoldWith<V>>::fold_with(block, visitor) };
-                KeyframeBlock {
-                    span,
-                    prelude,
-                    block,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
+                        self::fields::KeyframeBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
+                        self::fields::KeyframeBlockField::Prelude(usize::MAX),
+                    ));
+                    <Vec<KeyframeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
+                        self::fields::KeyframeBlockField::Block,
+                    ));
+                    <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for KeyframeSelector {
-    #[doc = "Calls [Fold`::fold_keyframe_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_keyframe_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframeSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframe_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             KeyframeSelector::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                KeyframeSelector::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
+                    self::fields::KeyframeSelectorField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframeSelector::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                KeyframeSelector::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
+                    self::fields::KeyframeSelectorField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for KeyframesName {
-    #[doc = "Calls [Fold`::fold_keyframes_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_keyframes_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframesName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframes_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             KeyframesName::CustomIdent { 0: _field_0 } => {
-                let _field_0 = <Box<CustomIdent> as FoldWith<V>>::fold_with(_field_0, visitor);
-                KeyframesName::CustomIdent { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::CustomIdent,
+                ));
+                <Box<CustomIdent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframesName::Str { 0: _field_0 } => {
-                let _field_0 = <Box<Str> as FoldWith<V>>::fold_with(_field_0, visitor);
-                KeyframesName::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::Str,
+                ));
+                <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframesName::PseudoPrefix { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<KeyframesPseudoPrefix> as FoldWith<V>>::fold_with(_field_0, visitor);
-                KeyframesName::PseudoPrefix { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::PseudoPrefix,
+                ));
+                <Box<KeyframesPseudoPrefix> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             KeyframesName::PseudoFunction { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<KeyframesPseudoFunction> as FoldWith<V>>::fold_with(_field_0, visitor);
-                KeyframesName::PseudoFunction { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::PseudoFunction,
+                ));
+                <Box<KeyframesPseudoFunction> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for KeyframesPseudoFunction {
-    #[doc = "Calls [Fold`::fold_keyframes_pseudo_function`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_keyframes_pseudo_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframesPseudoFunction {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframes_pseudo_function`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_function(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             KeyframesPseudoFunction { span, pseudo, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let pseudo = { <Ident as FoldWith<V>>::fold_with(pseudo, visitor) };
-                let name = { <KeyframesName as FoldWith<V>>::fold_with(name, visitor) };
-                KeyframesPseudoFunction { span, pseudo, name }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
+                            self::fields::KeyframesPseudoFunctionField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
+                            self::fields::KeyframesPseudoFunctionField::Pseudo,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        pseudo,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
+                            self::fields::KeyframesPseudoFunctionField::Name,
+                        ));
+                    <KeyframesName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for KeyframesPseudoPrefix {
-    #[doc = "Calls [Fold`::fold_keyframes_pseudo_prefix`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_keyframes_pseudo_prefix(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyframesPseudoPrefix {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframes_pseudo_prefix`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframes_pseudo_prefix(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             KeyframesPseudoPrefix { span, pseudo, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let pseudo = { <Ident as FoldWith<V>>::fold_with(pseudo, visitor) };
-                let name = { <KeyframesName as FoldWith<V>>::fold_with(name, visitor) };
-                KeyframesPseudoPrefix { span, pseudo, name }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
+                            self::fields::KeyframesPseudoPrefixField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
+                            self::fields::KeyframesPseudoPrefixField::Pseudo,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        pseudo,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
+                            self::fields::KeyframesPseudoPrefixField::Name,
+                        ));
+                    <KeyframesName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for LayerName {
-    #[doc = "Calls [Fold`::fold_layer_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_layer_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LayerName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             LayerName { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Vec<Ident> as FoldWith<V>>::fold_with(name, visitor) };
-                LayerName { span, name }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::LayerName(self::fields::LayerNameField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerName(
+                        self::fields::LayerNameField::Name(usize::MAX),
+                    ));
+                    <Vec<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for LayerNameList {
-    #[doc = "Calls [Fold`::fold_layer_name_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_layer_name_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LayerNameList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_name_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_name_list(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             LayerNameList { span, name_list } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name_list = { <Vec<LayerName> as FoldWith<V>>::fold_with(name_list, visitor) };
-                LayerNameList { span, name_list }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
+                        self::fields::LayerNameListField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
+                        self::fields::LayerNameListField::NameList(usize::MAX),
+                    ));
+                    <Vec<LayerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name_list,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for LayerPrelude {
-    #[doc = "Calls [Fold`::fold_layer_prelude`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_layer_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LayerPrelude {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_prelude`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_prelude(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             LayerPrelude::Name { 0: _field_0 } => {
-                let _field_0 = <LayerName as FoldWith<V>>::fold_with(_field_0, visitor);
-                LayerPrelude::Name { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
+                    self::fields::LayerPreludeField::Name,
+                ));
+                <LayerName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             LayerPrelude::NameList { 0: _field_0 } => {
-                let _field_0 = <LayerNameList as FoldWith<V>>::fold_with(_field_0, visitor);
-                LayerPrelude::NameList { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
+                    self::fields::LayerPreludeField::NameList,
+                ));
+                <LayerNameList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Length {
-    #[doc = "Calls [Fold`::fold_length`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_length(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Length {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_length`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_length(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Length { span, value, unit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
-                Length { span, value, unit }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Length(self::fields::LengthField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Length(self::fields::LengthField::Value));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Length(self::fields::LengthField::Unit));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for LengthPercentage {
-    #[doc = "Calls [Fold`::fold_length_percentage`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_length_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LengthPercentage {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_length_percentage`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_length_percentage(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             LengthPercentage::Length { 0: _field_0 } => {
-                let _field_0 = <Length as FoldWith<V>>::fold_with(_field_0, visitor);
-                LengthPercentage::Length { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
+                    self::fields::LengthPercentageField::Length,
+                ));
+                <Length as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             LengthPercentage::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                LengthPercentage::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
+                    self::fields::LengthPercentageField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ListOfComponentValues {
-    #[doc = "Calls [Fold`::fold_list_of_component_values`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_list_of_component_values(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ListOfComponentValues {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_list_of_component_values`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_list_of_component_values(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ListOfComponentValues { span, children } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let children =
-                    { <Vec<ComponentValue> as FoldWith<V>>::fold_with(children, visitor) };
-                ListOfComponentValues { span, children }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
+                            self::fields::ListOfComponentValuesField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
+                            self::fields::ListOfComponentValuesField::Children(usize::MAX),
+                        ));
+                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaAnd {
-    #[doc = "Calls [Fold`::fold_media_and`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaAnd {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_and`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_and(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaAnd {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let condition = { <MediaInParens as FoldWith<V>>::fold_with(condition, visitor) };
-                MediaAnd {
-                    span,
-                    keyword,
-                    condition,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaAnd(self::fields::MediaAndField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
+                        self::fields::MediaAndField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
+                        self::fields::MediaAndField::Condition,
+                    ));
+                    <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaCondition {
-    #[doc = "Calls [Fold`::fold_media_condition`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaCondition {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_condition(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaCondition { span, conditions } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let conditions =
-                    { <Vec<MediaConditionAllType> as FoldWith<V>>::fold_with(conditions, visitor) };
-                MediaCondition { span, conditions }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
+                        self::fields::MediaConditionField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
+                        self::fields::MediaConditionField::Conditions(usize::MAX),
+                    ));
+                    <Vec<MediaConditionAllType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionAllType {
-    #[doc = "Calls [Fold`::fold_media_condition_all_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_condition_all_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionAllType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_all_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_all_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaConditionAllType::Not { 0: _field_0 } => {
-                let _field_0 = <MediaNot as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionAllType::Not { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::Not,
+                ));
+                <MediaNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionAllType::And { 0: _field_0 } => {
-                let _field_0 = <MediaAnd as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionAllType::And { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::And,
+                ));
+                <MediaAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionAllType::Or { 0: _field_0 } => {
-                let _field_0 = <MediaOr as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionAllType::Or { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::Or,
+                ));
+                <MediaOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionAllType::MediaInParens { 0: _field_0 } => {
-                let _field_0 = <MediaInParens as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionAllType::MediaInParens { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::MediaInParens,
+                ));
+                <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionType {
-    #[doc = "Calls [Fold`::fold_media_condition_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_condition_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaConditionType::All { 0: _field_0 } => {
-                let _field_0 = <MediaCondition as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionType::All { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
+                    self::fields::MediaConditionTypeField::All,
+                ));
+                <MediaCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionType::WithoutOr { 0: _field_0 } => {
-                let _field_0 =
-                    <MediaConditionWithoutOr as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionType::WithoutOr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
+                    self::fields::MediaConditionTypeField::WithoutOr,
+                ));
+                <MediaConditionWithoutOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionWithoutOr {
-    #[doc = "Calls [Fold`::fold_media_condition_without_or`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_condition_without_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionWithoutOr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_without_or`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaConditionWithoutOr { span, conditions } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let conditions = {
-                    <Vec<MediaConditionWithoutOrType> as FoldWith<V>>::fold_with(
-                        conditions, visitor,
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
+                            self::fields::MediaConditionWithoutOrField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                MediaConditionWithoutOr { span, conditions }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
+                            self::fields::MediaConditionWithoutOrField::Conditions(usize::MAX),
+                        ));
+                    < Vec < MediaConditionWithoutOrType > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (conditions , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionWithoutOrType {
-    #[doc = "Calls [Fold`::fold_media_condition_without_or_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_condition_without_or_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaConditionWithoutOrType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_without_or_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaConditionWithoutOrType::Not { 0: _field_0 } => {
-                let _field_0 = <MediaNot as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionWithoutOrType::Not { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
+                        self::fields::MediaConditionWithoutOrTypeField::Not,
+                    ));
+                <MediaNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionWithoutOrType::And { 0: _field_0 } => {
-                let _field_0 = <MediaAnd as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionWithoutOrType::And { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
+                        self::fields::MediaConditionWithoutOrTypeField::And,
+                    ));
+                <MediaAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaConditionWithoutOrType::MediaInParens { 0: _field_0 } => {
-                let _field_0 = <MediaInParens as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaConditionWithoutOrType::MediaInParens { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
+                        self::fields::MediaConditionWithoutOrTypeField::MediaInParens,
+                    ));
+                <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeature {
-    #[doc = "Calls [Fold`::fold_media_feature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaFeature::Plain { 0: _field_0 } => {
-                let _field_0 = <MediaFeaturePlain as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeature::Plain { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::Plain,
+                ));
+                <MediaFeaturePlain as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeature::Boolean { 0: _field_0 } => {
-                let _field_0 = <MediaFeatureBoolean as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeature::Boolean { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::Boolean,
+                ));
+                <MediaFeatureBoolean as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeature::Range { 0: _field_0 } => {
-                let _field_0 = <MediaFeatureRange as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeature::Range { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::Range,
+                ));
+                <MediaFeatureRange as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeature::RangeInterval { 0: _field_0 } => {
-                let _field_0 =
-                    <MediaFeatureRangeInterval as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeature::RangeInterval { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::RangeInterval,
+                ));
+                <MediaFeatureRangeInterval as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureBoolean {
-    #[doc = "Calls [Fold`::fold_media_feature_boolean`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature_boolean(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureBoolean {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_boolean`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_boolean(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaFeatureBoolean { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <MediaFeatureName as FoldWith<V>>::fold_with(name, visitor) };
-                MediaFeatureBoolean { span, name }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
+                        self::fields::MediaFeatureBooleanField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
+                        self::fields::MediaFeatureBooleanField::Name,
+                    ));
+                    <MediaFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureName {
-    #[doc = "Calls [Fold`::fold_media_feature_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaFeatureName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeatureName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
+                    self::fields::MediaFeatureNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureName::ExtensionName { 0: _field_0 } => {
-                let _field_0 = <ExtensionName as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeatureName::ExtensionName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
+                    self::fields::MediaFeatureNameField::ExtensionName,
+                ));
+                <ExtensionName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeaturePlain {
-    #[doc = "Calls [Fold`::fold_media_feature_plain`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature_plain(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeaturePlain {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_plain`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_plain(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaFeaturePlain { span, name, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <MediaFeatureName as FoldWith<V>>::fold_with(name, visitor) };
-                let value = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(value, visitor) };
-                MediaFeaturePlain { span, name, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
+                        self::fields::MediaFeaturePlainField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
+                        self::fields::MediaFeaturePlainField::Name,
+                    ));
+                    <MediaFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
+                        self::fields::MediaFeaturePlainField::Value,
+                    ));
+                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRange {
-    #[doc = "Calls [Fold`::fold_media_feature_range`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRange {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_range`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaFeatureRange {
                 span,
@@ -84575,45 +67516,77 @@ impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRange {
                 comparison,
                 right,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
-                let comparison = {
-                    <MediaFeatureRangeComparison as FoldWith<V>>::fold_with(comparison, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Left,
+                    ));
+                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Comparison,
+                    ));
+                    <MediaFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        comparison,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Right,
+                    ));
+                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let right = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
-                MediaFeatureRange {
-                    span,
-                    left,
-                    comparison,
-                    right,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRangeComparison {
-    #[doc = "Calls [Fold`::fold_media_feature_range_comparison`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature_range_comparison(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRangeComparison {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_range_comparison`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range_comparison(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            MediaFeatureRangeComparison::Lt => MediaFeatureRangeComparison::Lt,
-            MediaFeatureRangeComparison::Le => MediaFeatureRangeComparison::Le,
-            MediaFeatureRangeComparison::Gt => MediaFeatureRangeComparison::Gt,
-            MediaFeatureRangeComparison::Ge => MediaFeatureRangeComparison::Ge,
-            MediaFeatureRangeComparison::Eq => MediaFeatureRangeComparison::Eq,
+            MediaFeatureRangeComparison::Lt => {}
+            MediaFeatureRangeComparison::Le => {}
+            MediaFeatureRangeComparison::Gt => {}
+            MediaFeatureRangeComparison::Ge => {}
+            MediaFeatureRangeComparison::Eq => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRangeInterval {
-    #[doc = "Calls [Fold`::fold_media_feature_range_interval`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature_range_interval(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureRangeInterval {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_range_interval`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_range_interval(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaFeatureRangeInterval {
                 span,
@@ -84623,145 +67596,286 @@ impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRangeInterval {
                 right_comparison,
                 right,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
-                let left_comparison = {
-                    <MediaFeatureRangeComparison as FoldWith<V>>::fold_with(
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Left,
+                        ));
+                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::LeftComparison,
+                        ));
+                    <MediaFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
                         left_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                let name = { <MediaFeatureName as FoldWith<V>>::fold_with(name, visitor) };
-                let right_comparison = {
-                    <MediaFeatureRangeComparison as FoldWith<V>>::fold_with(
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Name,
+                        ));
+                    <MediaFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::RightComparison,
+                        ));
+                    <MediaFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
                         right_comparison,
                         visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Right,
+                        ));
+                    <Box<MediaFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                let right = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
-                MediaFeatureRangeInterval {
-                    span,
-                    left,
-                    left_comparison,
-                    name,
-                    right_comparison,
-                    right,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureValue {
-    #[doc = "Calls [Fold`::fold_media_feature_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_feature_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaFeatureValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_feature_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_feature_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaFeatureValue::Number { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeatureValue::Number { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Number,
+                ));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Dimension { 0: _field_0 } => {
-                let _field_0 = <Dimension as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeatureValue::Dimension { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Dimension,
+                ));
+                <Dimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeatureValue::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Ratio { 0: _field_0 } => {
-                let _field_0 = <Ratio as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeatureValue::Ratio { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Ratio,
+                ));
+                <Ratio as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaFeatureValue::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaFeatureValue::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaInParens {
-    #[doc = "Calls [Fold`::fold_media_in_parens`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaInParens {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_in_parens`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_in_parens(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaInParens::MediaCondition { 0: _field_0 } => {
-                let _field_0 = <MediaCondition as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaInParens::MediaCondition { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
+                    self::fields::MediaInParensField::MediaCondition,
+                ));
+                <MediaCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaInParens::Feature { 0: _field_0 } => {
-                let _field_0 = <Box<MediaFeature> as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaInParens::Feature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
+                    self::fields::MediaInParensField::Feature,
+                ));
+                <Box<MediaFeature> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MediaInParens::GeneralEnclosed { 0: _field_0 } => {
-                let _field_0 = <GeneralEnclosed as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaInParens::GeneralEnclosed { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
+                    self::fields::MediaInParensField::GeneralEnclosed,
+                ));
+                <GeneralEnclosed as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaNot {
-    #[doc = "Calls [Fold`::fold_media_not`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaNot {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_not`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_not(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaNot {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let condition = { <MediaInParens as FoldWith<V>>::fold_with(condition, visitor) };
-                MediaNot {
-                    span,
-                    keyword,
-                    condition,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaNot(self::fields::MediaNotField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
+                        self::fields::MediaNotField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
+                        self::fields::MediaNotField::Condition,
+                    ));
+                    <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaOr {
-    #[doc = "Calls [Fold`::fold_media_or`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaOr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_or`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_or(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaOr {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let condition = { <MediaInParens as FoldWith<V>>::fold_with(condition, visitor) };
-                MediaOr {
-                    span,
-                    keyword,
-                    condition,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Keyword));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaOr(
+                        self::fields::MediaOrField::Condition,
+                    ));
+                    <MediaInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaQuery {
-    #[doc = "Calls [Fold`::fold_media_query`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaQuery {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_query`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_query(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaQuery {
                 span,
@@ -84770,761 +67884,1521 @@ impl<V: ?Sized + Fold> FoldWith<V> for MediaQuery {
                 keyword,
                 condition,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let modifier = { <Option<Ident> as FoldWith<V>>::fold_with(modifier, visitor) };
-                let media_type =
-                    { <Option<MediaType> as FoldWith<V>>::fold_with(media_type, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let condition = {
-                    <Option<Box<MediaConditionType>> as FoldWith<V>>::fold_with(condition, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Modifier,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        modifier,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::MediaType,
+                    ));
+                    <Option<MediaType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        media_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Condition,
+                    ));
+                    < Option < Box < MediaConditionType > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (condition , visitor , & mut * __ast_path)
                 };
-                MediaQuery {
-                    span,
-                    modifier,
-                    media_type,
-                    keyword,
-                    condition,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaQueryList {
-    #[doc = "Calls [Fold`::fold_media_query_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_query_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaQueryList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_query_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_query_list(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaQueryList { span, queries } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let queries = { <Vec<MediaQuery> as FoldWith<V>>::fold_with(queries, visitor) };
-                MediaQueryList { span, queries }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
+                        self::fields::MediaQueryListField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
+                        self::fields::MediaQueryListField::Queries(usize::MAX),
+                    ));
+                    <Vec<MediaQuery> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        queries,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MediaType {
-    #[doc = "Calls [Fold`::fold_media_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MediaType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MediaType::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                MediaType::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaType(
+                    self::fields::MediaTypeField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NamedNamespace {
-    #[doc = "Calls [Fold`::fold_named_namespace`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_named_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamedNamespace {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_named_namespace`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_named_namespace(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             NamedNamespace { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
-                NamedNamespace { span, name }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
+                        self::fields::NamedNamespaceField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
+                        self::fields::NamedNamespaceField::Name,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Namespace {
-    #[doc = "Calls [Fold`::fold_namespace`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Namespace {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_namespace(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Namespace::Named { 0: _field_0 } => {
-                let _field_0 = <NamedNamespace as FoldWith<V>>::fold_with(_field_0, visitor);
-                Namespace::Named { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Namespace(
+                    self::fields::NamespaceField::Named,
+                ));
+                <NamedNamespace as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Namespace::Any { 0: _field_0 } => {
-                let _field_0 = <AnyNamespace as FoldWith<V>>::fold_with(_field_0, visitor);
-                Namespace::Any { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Namespace(self::fields::NamespaceField::Any));
+                <AnyNamespace as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NamespacePrefix {
-    #[doc = "Calls [Fold`::fold_namespace_prefix`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_namespace_prefix(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamespacePrefix {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace_prefix`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prefix(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             NamespacePrefix { span, namespace } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let namespace =
-                    { <Option<Namespace> as FoldWith<V>>::fold_with(namespace, visitor) };
-                NamespacePrefix { span, namespace }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
+                        self::fields::NamespacePrefixField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
+                        self::fields::NamespacePrefixField::Namespace,
+                    ));
+                    <Option<Namespace> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        namespace,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NamespacePrelude {
-    #[doc = "Calls [Fold`::fold_namespace_prelude`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_namespace_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamespacePrelude {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace_prelude`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prelude(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             NamespacePrelude { span, prefix, uri } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let prefix = { <Option<Ident> as FoldWith<V>>::fold_with(prefix, visitor) };
-                let uri = { <Box<NamespacePreludeUri> as FoldWith<V>>::fold_with(uri, visitor) };
-                NamespacePrelude { span, prefix, uri }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
+                        self::fields::NamespacePreludeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
+                        self::fields::NamespacePreludeField::Prefix,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
+                        self::fields::NamespacePreludeField::Uri,
+                    ));
+                    <Box<NamespacePreludeUri> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        uri,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NamespacePreludeUri {
-    #[doc = "Calls [Fold`::fold_namespace_prelude_uri`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_namespace_prelude_uri(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamespacePreludeUri {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_namespace_prelude_uri`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_namespace_prelude_uri(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             NamespacePreludeUri::Url { 0: _field_0 } => {
-                let _field_0 = <Url as FoldWith<V>>::fold_with(_field_0, visitor);
-                NamespacePreludeUri::Url { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
+                    self::fields::NamespacePreludeUriField::Url,
+                ));
+                <Url as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             NamespacePreludeUri::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                NamespacePreludeUri::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
+                    self::fields::NamespacePreludeUriField::Str,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NestingSelector {
-    #[doc = "Calls [Fold`::fold_nesting_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_nesting_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NestingSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_nesting_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_nesting_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             NestingSelector { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                NestingSelector { span }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NestingSelector(
+                        self::fields::NestingSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Number {
-    #[doc = "Calls [Fold`::fold_number`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_number(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Number {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_number`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Number { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                Number { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NumberType {
-    #[doc = "Calls [Fold`::fold_number_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_number_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NumberType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_number_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            NumberType::Integer => NumberType::Integer,
-            NumberType::Number => NumberType::Number,
+            NumberType::Integer => {}
+            NumberType::Number => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PageSelector {
-    #[doc = "Calls [Fold`::fold_page_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_page_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PageSelector {
                 span,
                 page_type,
                 pseudos,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let page_type =
-                    { <Option<PageSelectorType> as FoldWith<V>>::fold_with(page_type, visitor) };
-                let pseudos = {
-                    <Option<Vec<PageSelectorPseudo>> as FoldWith<V>>::fold_with(pseudos, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
+                        self::fields::PageSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
+                        self::fields::PageSelectorField::PageType,
+                    ));
+                    <Option<PageSelectorType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        page_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
+                        self::fields::PageSelectorField::Pseudos(usize::MAX),
+                    ));
+                    < Option < Vec < PageSelectorPseudo > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (pseudos , visitor , & mut * __ast_path)
                 };
-                PageSelector {
-                    span,
-                    page_type,
-                    pseudos,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PageSelectorList {
-    #[doc = "Calls [Fold`::fold_page_selector_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_page_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelectorList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_list(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PageSelectorList { span, selectors } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let selectors =
-                    { <Vec<PageSelector> as FoldWith<V>>::fold_with(selectors, visitor) };
-                PageSelectorList { span, selectors }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
+                        self::fields::PageSelectorListField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
+                        self::fields::PageSelectorListField::Selectors(usize::MAX),
+                    ));
+                    <Vec<PageSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        selectors,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PageSelectorPseudo {
-    #[doc = "Calls [Fold`::fold_page_selector_pseudo`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_page_selector_pseudo(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelectorPseudo {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_pseudo`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_pseudo(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PageSelectorPseudo { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
-                PageSelectorPseudo { span, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
+                        self::fields::PageSelectorPseudoField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
+                        self::fields::PageSelectorPseudoField::Value,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PageSelectorType {
-    #[doc = "Calls [Fold`::fold_page_selector_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_page_selector_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PageSelectorType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PageSelectorType { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
-                PageSelectorType { span, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
+                        self::fields::PageSelectorTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
+                        self::fields::PageSelectorTypeField::Value,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Percentage {
-    #[doc = "Calls [Fold`::fold_percentage`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Percentage {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_percentage`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_percentage(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Percentage { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                Percentage { span, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
+                        self::fields::PercentageField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
+                        self::fields::PercentageField::Value,
+                    ));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PseudoClassSelector {
-    #[doc = "Calls [Fold`::fold_pseudo_class_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pseudo_class_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoClassSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_class_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PseudoClassSelector {
                 span,
                 name,
                 children,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
-                let children = {
-                    <Option<Vec<PseudoClassSelectorChildren>> as FoldWith<V>>::fold_with(
-                        children, visitor,
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
+                        self::fields::PseudoClassSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                PseudoClassSelector {
-                    span,
-                    name,
-                    children,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
+                        self::fields::PseudoClassSelectorField::Name,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
+                        self::fields::PseudoClassSelectorField::Children(usize::MAX),
+                    ));
+                    < Option < Vec < PseudoClassSelectorChildren > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PseudoClassSelectorChildren {
-    #[doc = "Calls [Fold`::fold_pseudo_class_selector_children`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pseudo_class_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoClassSelectorChildren {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_class_selector_children`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_children(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PseudoClassSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let _field_0 = <TokenAndSpan as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::PreservedToken { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::PreservedToken,
+                    ));
+                <TokenAndSpan as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::AnPlusB { 0: _field_0 } => {
-                let _field_0 = <AnPlusB as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::AnPlusB { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::AnPlusB,
+                    ));
+                <AnPlusB as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::Ident { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::Ident,
+                    ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::Str { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::Str,
+                    ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
-                let _field_0 = <Delimiter as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::Delimiter { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::Delimiter,
+                    ));
+                <Delimiter as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
-                let _field_0 = <ComplexSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::ComplexSelector,
+                    ));
+                <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::SelectorList { 0: _field_0 } => {
-                let _field_0 = <SelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::SelectorList { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::SelectorList,
+                    ));
+                <SelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 } => {
-                let _field_0 = <ForgivingSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::ForgivingSelectorList,
+                    ));
+                <ForgivingSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 } => {
-                let _field_0 = <CompoundSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::CompoundSelectorList,
+                    ));
+                <CompoundSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 } => {
-                let _field_0 = <RelativeSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::RelativeSelectorList,
+                    ));
+                <RelativeSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 } => {
-                let _field_0 =
-                    <ForgivingRelativeSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PseudoClassSelectorChildren(
+                    self::fields::PseudoClassSelectorChildrenField::ForgivingRelativeSelectorList,
+                ));
+                <ForgivingRelativeSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let _field_0 = <CompoundSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::CompoundSelector,
+                    ));
+                <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PseudoElementSelector {
-    #[doc = "Calls [Fold`::fold_pseudo_element_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pseudo_element_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoElementSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_element_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PseudoElementSelector {
                 span,
                 name,
                 children,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
-                let children = {
-                    <Option<Vec<PseudoElementSelectorChildren>> as FoldWith<V>>::fold_with(
-                        children, visitor,
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
+                            self::fields::PseudoElementSelectorField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                PseudoElementSelector {
-                    span,
-                    name,
-                    children,
-                }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
+                            self::fields::PseudoElementSelectorField::Name,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
+                            self::fields::PseudoElementSelectorField::Children(usize::MAX),
+                        ));
+                    < Option < Vec < PseudoElementSelectorChildren > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (children , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PseudoElementSelectorChildren {
-    #[doc = "Calls [Fold`::fold_pseudo_element_selector_children`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pseudo_element_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PseudoElementSelectorChildren {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_element_selector_children`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_children(
+            visitor, self, __ast_path,
+        )
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PseudoElementSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let _field_0 = <TokenAndSpan as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoElementSelectorChildren::PreservedToken { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::PreservedToken,
+                    ));
+                <TokenAndSpan as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoElementSelectorChildren::Ident { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::Ident,
+                    ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let _field_0 = <CompoundSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::CompoundSelector,
+                    ));
+                <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 } => {
-                let _field_0 = <CustomHighlightName as FoldWith<V>>::fold_with(_field_0, visitor);
-                PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::CustomHighlightName,
+                    ));
+                <CustomHighlightName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for QualifiedRule {
-    #[doc = "Calls [Fold`::fold_qualified_rule`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_qualified_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for QualifiedRule {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_qualified_rule`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_qualified_rule(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             QualifiedRule {
                 span,
                 prelude,
                 block,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let prelude =
-                    { <QualifiedRulePrelude as FoldWith<V>>::fold_with(prelude, visitor) };
-                let block = { <SimpleBlock as FoldWith<V>>::fold_with(block, visitor) };
-                QualifiedRule {
-                    span,
-                    prelude,
-                    block,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
+                        self::fields::QualifiedRuleField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
+                        self::fields::QualifiedRuleField::Prelude,
+                    ));
+                    <QualifiedRulePrelude as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
+                        self::fields::QualifiedRuleField::Block,
+                    ));
+                    <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for QualifiedRulePrelude {
-    #[doc = "Calls [Fold`::fold_qualified_rule_prelude`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_qualified_rule_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for QualifiedRulePrelude {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_qualified_rule_prelude`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_qualified_rule_prelude(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             QualifiedRulePrelude::SelectorList { 0: _field_0 } => {
-                let _field_0 = <SelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                QualifiedRulePrelude::SelectorList { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
+                    self::fields::QualifiedRulePreludeField::SelectorList,
+                ));
+                <SelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 } => {
-                let _field_0 = <RelativeSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
-                QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
+                    self::fields::QualifiedRulePreludeField::RelativeSelectorList,
+                ));
+                <RelativeSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
-                QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
+                    self::fields::QualifiedRulePreludeField::ListOfComponentValues,
+                ));
+                <ListOfComponentValues as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for QueryInParens {
-    #[doc = "Calls [Fold`::fold_query_in_parens`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_query_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for QueryInParens {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_query_in_parens`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_query_in_parens(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             QueryInParens::ContainerQuery { 0: _field_0 } => {
-                let _field_0 = <Box<ContainerQuery> as FoldWith<V>>::fold_with(_field_0, visitor);
-                QueryInParens::ContainerQuery { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
+                    self::fields::QueryInParensField::ContainerQuery,
+                ));
+                <Box<ContainerQuery> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QueryInParens::SizeFeature { 0: _field_0 } => {
-                let _field_0 = <SizeFeature as FoldWith<V>>::fold_with(_field_0, visitor);
-                QueryInParens::SizeFeature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
+                    self::fields::QueryInParensField::SizeFeature,
+                ));
+                <SizeFeature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             QueryInParens::GeneralEnclosed { 0: _field_0 } => {
-                let _field_0 = <GeneralEnclosed as FoldWith<V>>::fold_with(_field_0, visitor);
-                QueryInParens::GeneralEnclosed { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
+                    self::fields::QueryInParensField::GeneralEnclosed,
+                ));
+                <GeneralEnclosed as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Ratio {
-    #[doc = "Calls [Fold`::fold_ratio`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ratio(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Ratio {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ratio`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ratio(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Ratio { span, left, right } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <Number as FoldWith<V>>::fold_with(left, visitor) };
-                let right = { <Option<Number> as FoldWith<V>>::fold_with(right, visitor) };
-                Ratio { span, left, right }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Left));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Ratio(self::fields::RatioField::Right));
+                    <Option<Number> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for RelativeSelector {
-    #[doc = "Calls [Fold`::fold_relative_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_relative_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for RelativeSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_relative_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_relative_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             RelativeSelector {
                 span,
-                combinator,
-                selector,
-            } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let combinator =
-                    { <Option<Combinator> as FoldWith<V>>::fold_with(combinator, visitor) };
-                let selector = { <ComplexSelector as FoldWith<V>>::fold_with(selector, visitor) };
-                RelativeSelector {
-                    span,
-                    combinator,
-                    selector,
-                }
+                combinator,
+                selector,
+            } => {
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
+                        self::fields::RelativeSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
+                        self::fields::RelativeSelectorField::Combinator,
+                    ));
+                    <Option<Combinator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        combinator,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
+                        self::fields::RelativeSelectorField::Selector,
+                    ));
+                    <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        selector,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for RelativeSelectorList {
-    #[doc = "Calls [Fold`::fold_relative_selector_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_relative_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for RelativeSelectorList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_relative_selector_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_relative_selector_list(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             RelativeSelectorList { span, children } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let children =
-                    { <Vec<RelativeSelector> as FoldWith<V>>::fold_with(children, visitor) };
-                RelativeSelectorList { span, children }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
+                            self::fields::RelativeSelectorListField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
+                            self::fields::RelativeSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<RelativeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Resolution {
-    #[doc = "Calls [Fold`::fold_resolution`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_resolution(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Resolution {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_resolution`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_resolution(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Resolution { span, value, unit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
-                Resolution { span, value, unit }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
+                        self::fields::ResolutionField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
+                        self::fields::ResolutionField::Value,
+                    ));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
+                        self::fields::ResolutionField::Unit,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Rule {
-    #[doc = "Calls [Fold`::fold_rule`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Rule {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_rule`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rule(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Rule::QualifiedRule { 0: _field_0 } => {
-                let _field_0 = <Box<QualifiedRule> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Rule::QualifiedRule { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Rule(self::fields::RuleField::QualifiedRule));
+                <Box<QualifiedRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Rule::AtRule { 0: _field_0 } => {
-                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Rule::AtRule { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Rule(self::fields::RuleField::AtRule));
+                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Rule::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Rule::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Rule(
+                    self::fields::RuleField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ScopeRange {
-    #[doc = "Calls [Fold`::fold_scope_range`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_scope_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ScopeRange {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_scope_range`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_scope_range(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ScopeRange {
                 span,
                 scope_start,
                 scope_end,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let scope_start = {
-                    <Option<ForgivingSelectorList> as FoldWith<V>>::fold_with(scope_start, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
+                        self::fields::ScopeRangeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let scope_end = {
-                    <Option<ForgivingSelectorList> as FoldWith<V>>::fold_with(scope_end, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
+                        self::fields::ScopeRangeField::ScopeStart,
+                    ));
+                    < Option < ForgivingSelectorList > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (scope_start , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
+                        self::fields::ScopeRangeField::ScopeEnd,
+                    ));
+                    < Option < ForgivingSelectorList > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (scope_end , visitor , & mut * __ast_path)
                 };
-                ScopeRange {
-                    span,
-                    scope_start,
-                    scope_end,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SelectorList {
-    #[doc = "Calls [Fold`::fold_selector_list`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SelectorList {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_selector_list`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_selector_list(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SelectorList { span, children } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let children =
-                    { <Vec<ComplexSelector> as FoldWith<V>>::fold_with(children, visitor) };
-                SelectorList { span, children }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
+                        self::fields::SelectorListField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
+                        self::fields::SelectorListField::Children(usize::MAX),
+                    ));
+                    <Vec<ComplexSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SequenceOfCustomIdents {
-    #[doc = "Calls [Fold`::fold_sequence_of_custom_idents`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_sequence_of_custom_idents(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SequenceOfCustomIdents {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_sequence_of_custom_idents`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_sequence_of_custom_idents(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SequenceOfCustomIdents { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Vec<CustomIdent> as FoldWith<V>>::fold_with(value, visitor) };
-                SequenceOfCustomIdents { span, value }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
+                            self::fields::SequenceOfCustomIdentsField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
+                            self::fields::SequenceOfCustomIdentsField::Value(usize::MAX),
+                        ));
+                    <Vec<CustomIdent> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SimpleBlock {
-    #[doc = "Calls [Fold`::fold_simple_block`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_simple_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SimpleBlock {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_simple_block`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_simple_block(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SimpleBlock { span, name, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <TokenAndSpan as FoldWith<V>>::fold_with(name, visitor) };
-                let value = { <Vec<ComponentValue> as FoldWith<V>>::fold_with(value, visitor) };
-                SimpleBlock { span, name, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
+                        self::fields::SimpleBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
+                        self::fields::SimpleBlockField::Name,
+                    ));
+                    <TokenAndSpan as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
+                        self::fields::SimpleBlockField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeature {
-    #[doc = "Calls [Fold`::fold_size_feature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SizeFeature::Plain { 0: _field_0 } => {
-                let _field_0 = <SizeFeaturePlain as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeature::Plain { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::Plain,
+                ));
+                <SizeFeaturePlain as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeature::Boolean { 0: _field_0 } => {
-                let _field_0 = <SizeFeatureBoolean as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeature::Boolean { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::Boolean,
+                ));
+                <SizeFeatureBoolean as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeature::Range { 0: _field_0 } => {
-                let _field_0 = <SizeFeatureRange as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeature::Range { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::Range,
+                ));
+                <SizeFeatureRange as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeature::RangeInterval { 0: _field_0 } => {
-                let _field_0 =
-                    <SizeFeatureRangeInterval as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeature::RangeInterval { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::RangeInterval,
+                ));
+                <SizeFeatureRangeInterval as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureBoolean {
-    #[doc = "Calls [Fold`::fold_size_feature_boolean`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature_boolean(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureBoolean {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_boolean`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_boolean(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SizeFeatureBoolean { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <SizeFeatureName as FoldWith<V>>::fold_with(name, visitor) };
-                SizeFeatureBoolean { span, name }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
+                        self::fields::SizeFeatureBooleanField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
+                        self::fields::SizeFeatureBooleanField::Name,
+                    ));
+                    <SizeFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureName {
-    #[doc = "Calls [Fold`::fold_size_feature_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SizeFeatureName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeatureName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureName(
+                    self::fields::SizeFeatureNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeaturePlain {
-    #[doc = "Calls [Fold`::fold_size_feature_plain`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature_plain(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeaturePlain {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_plain`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_plain(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SizeFeaturePlain { span, name, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <SizeFeatureName as FoldWith<V>>::fold_with(name, visitor) };
-                let value = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(value, visitor) };
-                SizeFeaturePlain { span, name, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
+                        self::fields::SizeFeaturePlainField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
+                        self::fields::SizeFeaturePlainField::Name,
+                    ));
+                    <SizeFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
+                        self::fields::SizeFeaturePlainField::Value,
+                    ));
+                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRange {
-    #[doc = "Calls [Fold`::fold_size_feature_range`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRange {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_range`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SizeFeatureRange {
                 span,
@@ -85532,44 +69406,77 @@ impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRange {
                 comparison,
                 right,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
-                let comparison =
-                    { <SizeFeatureRangeComparison as FoldWith<V>>::fold_with(comparison, visitor) };
-                let right = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
-                SizeFeatureRange {
-                    span,
-                    left,
-                    comparison,
-                    right,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Left,
+                    ));
+                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Comparison,
+                    ));
+                    <SizeFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        comparison,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Right,
+                    ));
+                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRangeComparison {
-    #[doc = "Calls [Fold`::fold_size_feature_range_comparison`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature_range_comparison(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRangeComparison {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_range_comparison`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range_comparison(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            SizeFeatureRangeComparison::Lt => SizeFeatureRangeComparison::Lt,
-            SizeFeatureRangeComparison::Le => SizeFeatureRangeComparison::Le,
-            SizeFeatureRangeComparison::Gt => SizeFeatureRangeComparison::Gt,
-            SizeFeatureRangeComparison::Ge => SizeFeatureRangeComparison::Ge,
-            SizeFeatureRangeComparison::Eq => SizeFeatureRangeComparison::Eq,
+            SizeFeatureRangeComparison::Lt => {}
+            SizeFeatureRangeComparison::Le => {}
+            SizeFeatureRangeComparison::Gt => {}
+            SizeFeatureRangeComparison::Ge => {}
+            SizeFeatureRangeComparison::Eq => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRangeInterval {
-    #[doc = "Calls [Fold`::fold_size_feature_range_interval`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature_range_interval(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureRangeInterval {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_range_interval`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_range_interval(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SizeFeatureRangeInterval {
                 span,
@@ -85579,499 +69486,1077 @@ impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRangeInterval {
                 right_comparison,
                 right,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
-                let left_comparison = {
-                    <SizeFeatureRangeComparison as FoldWith<V>>::fold_with(left_comparison, visitor)
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let name = { <SizeFeatureName as FoldWith<V>>::fold_with(name, visitor) };
-                let right_comparison = {
-                    <SizeFeatureRangeComparison as FoldWith<V>>::fold_with(
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Left,
+                        ));
+                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::LeftComparison,
+                        ));
+                    <SizeFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left_comparison,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Name,
+                        ));
+                    <SizeFeatureName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::RightComparison,
+                        ));
+                    <SizeFeatureRangeComparison as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
                         right_comparison,
                         visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Right,
+                        ));
+                    <Box<SizeFeatureValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                let right = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
-                SizeFeatureRangeInterval {
-                    span,
-                    left,
-                    left_comparison,
-                    name,
-                    right_comparison,
-                    right,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureValue {
-    #[doc = "Calls [Fold`::fold_size_feature_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_size_feature_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SizeFeatureValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_size_feature_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_size_feature_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SizeFeatureValue::Number { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeatureValue::Number { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Number,
+                ));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Dimension { 0: _field_0 } => {
-                let _field_0 = <Dimension as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeatureValue::Dimension { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Dimension,
+                ));
+                <Dimension as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeatureValue::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Ratio { 0: _field_0 } => {
-                let _field_0 = <Ratio as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeatureValue::Ratio { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Ratio,
+                ));
+                <Ratio as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SizeFeatureValue::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                SizeFeatureValue::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Str {
-    #[doc = "Calls [Fold`::fold_str`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_str(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Str {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_str`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_str(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Str { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                Str { span, value, raw }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for StyleBlock {
-    #[doc = "Calls [Fold`::fold_style_block`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_style_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for StyleBlock {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_style_block`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_style_block(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             StyleBlock::AtRule { 0: _field_0 } => {
-                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
-                StyleBlock::AtRule { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::AtRule,
+                ));
+                <Box<AtRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             StyleBlock::Declaration { 0: _field_0 } => {
-                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
-                StyleBlock::Declaration { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::Declaration,
+                ));
+                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             StyleBlock::QualifiedRule { 0: _field_0 } => {
-                let _field_0 = <Box<QualifiedRule> as FoldWith<V>>::fold_with(_field_0, visitor);
-                StyleBlock::QualifiedRule { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::QualifiedRule,
+                ));
+                <Box<QualifiedRule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             StyleBlock::ListOfComponentValues { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
-                StyleBlock::ListOfComponentValues { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::ListOfComponentValues,
+                ));
+                <Box<ListOfComponentValues> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Stylesheet {
-    #[doc = "Calls [Fold`::fold_stylesheet`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_stylesheet(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Stylesheet {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_stylesheet`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stylesheet(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Stylesheet { span, rules } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let rules = { <Vec<Rule> as FoldWith<V>>::fold_with(rules, visitor) };
-                Stylesheet { span, rules }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
+                        self::fields::StylesheetField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
+                        self::fields::StylesheetField::Rules(usize::MAX),
+                    ));
+                    <Vec<Rule> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        rules,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SubclassSelector {
-    #[doc = "Calls [Fold`::fold_subclass_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_subclass_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SubclassSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_subclass_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_subclass_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SubclassSelector::Id { 0: _field_0 } => {
-                let _field_0 = <IdSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                SubclassSelector::Id { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::Id,
+                ));
+                <IdSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::Class { 0: _field_0 } => {
-                let _field_0 = <ClassSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                SubclassSelector::Class { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::Class,
+                ));
+                <ClassSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::Attribute { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<AttributeSelector> as FoldWith<V>>::fold_with(_field_0, visitor);
-                SubclassSelector::Attribute { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::Attribute,
+                ));
+                <Box<AttributeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::PseudoClass { 0: _field_0 } => {
-                let _field_0 = <PseudoClassSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                SubclassSelector::PseudoClass { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::PseudoClass,
+                ));
+                <PseudoClassSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SubclassSelector::PseudoElement { 0: _field_0 } => {
-                let _field_0 = <PseudoElementSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                SubclassSelector::PseudoElement { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::PseudoElement,
+                ));
+                <PseudoElementSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SupportsAnd {
-    #[doc = "Calls [Fold`::fold_supports_and`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsAnd {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_and`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_and(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SupportsAnd {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let condition =
-                    { <Box<SupportsInParens> as FoldWith<V>>::fold_with(condition, visitor) };
-                SupportsAnd {
-                    span,
-                    keyword,
-                    condition,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
+                        self::fields::SupportsAndField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
+                        self::fields::SupportsAndField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
+                        self::fields::SupportsAndField::Condition,
+                    ));
+                    <Box<SupportsInParens> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SupportsCondition {
-    #[doc = "Calls [Fold`::fold_supports_condition`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsCondition {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_condition`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SupportsCondition { span, conditions } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let conditions =
-                    { <Vec<SupportsConditionType> as FoldWith<V>>::fold_with(conditions, visitor) };
-                SupportsCondition { span, conditions }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
+                        self::fields::SupportsConditionField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
+                        self::fields::SupportsConditionField::Conditions(usize::MAX),
+                    ));
+                    <Vec<SupportsConditionType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SupportsConditionType {
-    #[doc = "Calls [Fold`::fold_supports_condition_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_condition_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsConditionType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_condition_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SupportsConditionType::Not { 0: _field_0 } => {
-                let _field_0 = <SupportsNot as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsConditionType::Not { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::Not,
+                ));
+                <SupportsNot as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsConditionType::And { 0: _field_0 } => {
-                let _field_0 = <SupportsAnd as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsConditionType::And { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::And,
+                ));
+                <SupportsAnd as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsConditionType::Or { 0: _field_0 } => {
-                let _field_0 = <SupportsOr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsConditionType::Or { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::Or,
+                ));
+                <SupportsOr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsConditionType::SupportsInParens { 0: _field_0 } => {
-                let _field_0 = <SupportsInParens as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsConditionType::SupportsInParens { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::SupportsInParens,
+                ));
+                <SupportsInParens as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SupportsFeature {
-    #[doc = "Calls [Fold`::fold_supports_feature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsFeature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_feature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_feature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SupportsFeature::Declaration { 0: _field_0 } => {
-                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsFeature::Declaration { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
+                    self::fields::SupportsFeatureField::Declaration,
+                ));
+                <Box<Declaration> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsFeature::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsFeature::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
+                    self::fields::SupportsFeatureField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SupportsInParens {
-    #[doc = "Calls [Fold`::fold_supports_in_parens`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsInParens {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_in_parens`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_in_parens(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SupportsInParens::SupportsCondition { 0: _field_0 } => {
-                let _field_0 = <SupportsCondition as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsInParens::SupportsCondition { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
+                    self::fields::SupportsInParensField::SupportsCondition,
+                ));
+                <SupportsCondition as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsInParens::Feature { 0: _field_0 } => {
-                let _field_0 = <SupportsFeature as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsInParens::Feature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
+                    self::fields::SupportsInParensField::Feature,
+                ));
+                <SupportsFeature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SupportsInParens::GeneralEnclosed { 0: _field_0 } => {
-                let _field_0 = <GeneralEnclosed as FoldWith<V>>::fold_with(_field_0, visitor);
-                SupportsInParens::GeneralEnclosed { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
+                    self::fields::SupportsInParensField::GeneralEnclosed,
+                ));
+                <GeneralEnclosed as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SupportsNot {
-    #[doc = "Calls [Fold`::fold_supports_not`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsNot {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_not`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_not(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SupportsNot {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let condition =
-                    { <Box<SupportsInParens> as FoldWith<V>>::fold_with(condition, visitor) };
-                SupportsNot {
-                    span,
-                    keyword,
-                    condition,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
+                        self::fields::SupportsNotField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
+                        self::fields::SupportsNotField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
+                        self::fields::SupportsNotField::Condition,
+                    ));
+                    <Box<SupportsInParens> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SupportsOr {
-    #[doc = "Calls [Fold`::fold_supports_or`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SupportsOr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_or`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_or(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SupportsOr {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
-                let condition =
-                    { <Box<SupportsInParens> as FoldWith<V>>::fold_with(condition, visitor) };
-                SupportsOr {
-                    span,
-                    keyword,
-                    condition,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
+                        self::fields::SupportsOrField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
+                        self::fields::SupportsOrField::Keyword,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
+                        self::fields::SupportsOrField::Condition,
+                    ));
+                    <Box<SupportsInParens> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TagNameSelector {
-    #[doc = "Calls [Fold`::fold_tag_name_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_tag_name_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TagNameSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_tag_name_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tag_name_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TagNameSelector { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <WqName as FoldWith<V>>::fold_with(name, visitor) };
-                TagNameSelector { span, name }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
+                        self::fields::TagNameSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
+                        self::fields::TagNameSelectorField::Name,
+                    ));
+                    <WqName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Time {
-    #[doc = "Calls [Fold`::fold_time`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_time(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Time {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_time`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_time(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Time { span, value, unit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
-                Time { span, value, unit }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Value));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Unit));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TimePercentage {
-    #[doc = "Calls [Fold`::fold_time_percentage`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_time_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TimePercentage {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_time_percentage`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_time_percentage(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TimePercentage::Time { 0: _field_0 } => {
-                let _field_0 = <Time as FoldWith<V>>::fold_with(_field_0, visitor);
-                TimePercentage::Time { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
+                    self::fields::TimePercentageField::Time,
+                ));
+                <Time as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TimePercentage::Percentage { 0: _field_0 } => {
-                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
-                TimePercentage::Percentage { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
+                    self::fields::TimePercentageField::Percentage,
+                ));
+                <Percentage as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Token {
-    #[doc = "Calls [Fold`::fold_token`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_token(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Token {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_token`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_token(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Token::Ident { value, raw } => {
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::Ident { value, raw }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Ident));
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::Function { value, raw } => {
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::Function { value, raw }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Function));
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::AtKeyword { value, raw } => {
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::AtKeyword { value, raw }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::AtKeyword));
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::Hash { is_id, value, raw } => {
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::Hash { is_id, value, raw }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Hash));
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::String { value, raw } => {
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::String { value, raw }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::String));
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::BadString { raw } => {
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::BadString { raw }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::BadString));
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::Url { value, raw } => {
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Box<UrlKeyValue> as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::Url { value, raw }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Url));
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <Box<UrlKeyValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::BadUrl { raw } => {
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::BadUrl { raw }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::BadUrl));
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+            }
+            Token::Delim { value } => {
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Delim));
             }
-            Token::Delim { value } => Token::Delim { value },
             Token::Number {
                 value,
                 raw,
                 type_flag,
             } => {
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                let type_flag = { <NumberType as FoldWith<V>>::fold_with(type_flag, visitor) };
-                Token::Number {
-                    value,
-                    raw,
-                    type_flag,
-                }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Number));
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::TypeFlag));
+                    <NumberType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_flag,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::Percentage { value, raw } => {
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                Token::Percentage { value, raw }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::Percentage));
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
             Token::Dimension { 0: _field_0 } => {
-                let _field_0 = <Box<DimensionToken> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Token::Dimension { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::Dimension));
+                <Box<DimensionToken> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Token::WhiteSpace { value } => {
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                Token::WhiteSpace { value }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::WhiteSpace));
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
-            Token::CDO => Token::CDO,
-            Token::CDC => Token::CDC,
-            Token::Colon => Token::Colon,
-            Token::Semi => Token::Semi,
-            Token::Comma => Token::Comma,
-            Token::LBracket => Token::LBracket,
-            Token::RBracket => Token::RBracket,
-            Token::LParen => Token::LParen,
-            Token::RParen => Token::RParen,
-            Token::LBrace => Token::LBrace,
-            Token::RBrace => Token::RBrace,
+            Token::CDO => {}
+            Token::CDC => {}
+            Token::Colon => {}
+            Token::Semi => {}
+            Token::Comma => {}
+            Token::LBracket => {}
+            Token::RBracket => {}
+            Token::LParen => {}
+            Token::RParen => {}
+            Token::LBrace => {}
+            Token::RBrace => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TokenAndSpan {
-    #[doc = "Calls [Fold`::fold_token_and_span`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_token_and_span(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TokenAndSpan {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_token_and_span`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_token_and_span(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TokenAndSpan { span, token } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let token = { <Token as FoldWith<V>>::fold_with(token, visitor) };
-                TokenAndSpan { span, token }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
+                        self::fields::TokenAndSpanField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
+                        self::fields::TokenAndSpanField::Token,
+                    ));
+                    <Token as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TypeSelector {
-    #[doc = "Calls [Fold`::fold_type_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_type_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TypeSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_type_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_type_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TypeSelector::TagName { 0: _field_0 } => {
-                let _field_0 = <TagNameSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                TypeSelector::TagName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
+                    self::fields::TypeSelectorField::TagName,
+                ));
+                <TagNameSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TypeSelector::Universal { 0: _field_0 } => {
-                let _field_0 = <UniversalSelector as FoldWith<V>>::fold_with(_field_0, visitor);
-                TypeSelector::Universal { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
+                    self::fields::TypeSelectorField::Universal,
+                ));
+                <UniversalSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UnicodeRange {
-    #[doc = "Calls [Fold`::fold_unicode_range`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_unicode_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnicodeRange {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_unicode_range`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unicode_range(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UnicodeRange {
                 span,
@@ -86079,61 +70564,139 @@ impl<V: ?Sized + Fold> FoldWith<V> for UnicodeRange {
                 end,
                 raw,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let start = { <swc_atoms::Atom as FoldWith<V>>::fold_with(start, visitor) };
-                let end = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(end, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                UnicodeRange {
-                    span,
-                    start,
-                    end,
-                    raw,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::Start,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        start,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::End,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        end,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UniversalSelector {
-    #[doc = "Calls [Fold`::fold_universal_selector`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_universal_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UniversalSelector {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_universal_selector`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_universal_selector(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UniversalSelector { span, prefix } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let prefix =
-                    { <Option<NamespacePrefix> as FoldWith<V>>::fold_with(prefix, visitor) };
-                UniversalSelector { span, prefix }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
+                        self::fields::UniversalSelectorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
+                        self::fields::UniversalSelectorField::Prefix,
+                    ));
+                    <Option<NamespacePrefix> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UnknownDimension {
-    #[doc = "Calls [Fold`::fold_unknown_dimension`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_unknown_dimension(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnknownDimension {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_unknown_dimension`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unknown_dimension(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UnknownDimension { span, value, unit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
-                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
-                UnknownDimension { span, value, unit }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
+                        self::fields::UnknownDimensionField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
+                        self::fields::UnknownDimensionField::Value,
+                    ));
+                    <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
+                        self::fields::UnknownDimensionField::Unit,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Url {
-    #[doc = "Calls [Fold`::fold_url`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_url(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Url {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_url`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Url {
                 span,
@@ -86141,7479 +70704,5943 @@ impl<V: ?Sized + Fold> FoldWith<V> for Url {
                 value,
                 modifiers,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
-                let value = { <Option<Box<UrlValue>> as FoldWith<V>>::fold_with(value, visitor) };
-                let modifiers =
-                    { <Option<Vec<UrlModifier>> as FoldWith<V>>::fold_with(modifiers, visitor) };
-                Url {
-                    span,
-                    name,
-                    value,
-                    modifiers,
-                }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Name));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Value));
+                    <Option<Box<UrlValue>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Url(
+                        self::fields::UrlField::Modifiers(usize::MAX),
+                    ));
+                    <Option<Vec<UrlModifier>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        modifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UrlKeyValue {
-    #[doc = "Calls [Fold`::fold_url_key_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_url_key_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlKeyValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_key_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_key_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UrlKeyValue {
                 0: _field_0,
                 1: _field_1,
             } => {
-                let _field_0 = <swc_atoms::Atom as FoldWith<V>>::fold_with(_field_0, visitor);
-                let _field_1 = <swc_atoms::Atom as FoldWith<V>>::fold_with(_field_1, visitor);
-                UrlKeyValue {
-                    0: _field_0,
-                    1: _field_1,
-                }
+                <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_1,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UrlModifier {
-    #[doc = "Calls [Fold`::fold_url_modifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_url_modifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlModifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_modifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_modifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UrlModifier::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                UrlModifier::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
+                    self::fields::UrlModifierField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             UrlModifier::Function { 0: _field_0 } => {
-                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
-                UrlModifier::Function { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
+                    self::fields::UrlModifierField::Function,
+                ));
+                <Function as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UrlValue {
-    #[doc = "Calls [Fold`::fold_url_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_url_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UrlValue::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                UrlValue::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Str));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             UrlValue::Raw { 0: _field_0 } => {
-                let _field_0 = <UrlValueRaw as FoldWith<V>>::fold_with(_field_0, visitor);
-                UrlValue::Raw { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Raw));
+                <UrlValueRaw as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UrlValueRaw {
-    #[doc = "Calls [Fold`::fold_url_value_raw`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_url_value_raw(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UrlValueRaw {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_value_raw`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_value_raw(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UrlValueRaw { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                UrlValueRaw { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
+                        self::fields::UrlValueRawField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
+                        self::fields::UrlValueRawField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
+                        self::fields::UrlValueRawField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for WqName {
-    #[doc = "Calls [Fold`::fold_wq_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_wq_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WqName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_wq_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_wq_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             WqName {
                 span,
                 prefix,
                 value,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let prefix =
-                    { <Option<NamespacePrefix> as FoldWith<V>>::fold_with(prefix, visitor) };
-                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
-                WqName {
-                    span,
-                    prefix,
-                    value,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Prefix));
+                    <Option<NamespacePrefix> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Value));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_atom(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        {}
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<CalcProductOrOperator> {
-    #[doc = "Calls [Fold`::fold_calc_product_or_operators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CalcProductOrOperator> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_product_or_operators`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_product_or_operators(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_product_or_operators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <CalcProductOrOperator as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CalcProductOrOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<CalcValueOrOperator> {
-    #[doc = "Calls [Fold`::fold_calc_value_or_operators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CalcValueOrOperator> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_calc_value_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_calc_value_or_operators(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_calc_value_or_operators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <CalcValueOrOperator as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CalcValueOrOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelectorChildren> {
-    #[doc = "Calls [Fold`::fold_complex_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComplexSelectorChildren> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_complex_selector_childrens(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_complex_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ComplexSelectorChildren as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ComplexSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelector> {
-    #[doc = "Calls [Fold`::fold_complex_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComplexSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_complex_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_complex_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ComplexSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComponentValue> {
-    #[doc = "Calls [Fold`::fold_component_values`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComponentValue> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_component_values`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_component_values(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_component_values(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ComponentValue as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ComponentValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<CompoundSelector> {
-    #[doc = "Calls [Fold`::fold_compound_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CompoundSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_compound_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_compound_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_compound_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <CompoundSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ContainerQueryType> {
-    #[doc = "Calls [Fold`::fold_container_query_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ContainerQueryType> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_container_query_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_container_query_types(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_container_query_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ContainerQueryType as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ContainerQueryType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<CustomIdent> {
-    #[doc = "Calls [Fold`::fold_custom_idents`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CustomIdent> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_custom_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_custom_idents(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_custom_idents(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <CustomIdent as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <CustomIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<DocumentPreludeMatchingFunction> {
-    #[doc = "Calls [Fold`::fold_document_prelude_matching_functions`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<DocumentPreludeMatchingFunction> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_document_prelude_matching_functions`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_document_prelude_matching_functions(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_document_prelude_matching_functions(
+            visitor, self, __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <DocumentPreludeMatchingFunction as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <DocumentPreludeMatchingFunction as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<FamilyName> {
-    #[doc = "Calls [Fold`::fold_family_names`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<FamilyName> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_family_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_family_names(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_family_names(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <FamilyName as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <FamilyName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingComplexSelector> {
-    #[doc = "Calls [Fold`::fold_forgiving_complex_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingComplexSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_complex_selectors`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_forgiving_complex_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_complex_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ForgivingComplexSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ForgivingComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingRelativeSelector> {
-    #[doc = "Calls [Fold`::fold_forgiving_relative_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingRelativeSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_forgiving_relative_selectors`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_forgiving_relative_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_forgiving_relative_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ForgivingRelativeSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ForgivingRelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Ident> {
-    #[doc = "Calls [Fold`::fold_idents`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Ident> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_idents(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_idents(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Ident as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<KeyframeSelector> {
-    #[doc = "Calls [Fold`::fold_keyframe_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<KeyframeSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_keyframe_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_keyframe_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_keyframe_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <KeyframeSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <KeyframeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<LayerName> {
-    #[doc = "Calls [Fold`::fold_layer_names`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<LayerName> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_layer_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_layer_names(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_layer_names(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <LayerName as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <LayerName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaConditionAllType> {
-    #[doc = "Calls [Fold`::fold_media_condition_all_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaConditionAllType> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_all_types`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_condition_all_types(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_all_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <MediaConditionAllType as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <MediaConditionAllType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaConditionWithoutOrType> {
-    #[doc = "Calls [Fold`::fold_media_condition_without_or_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaConditionWithoutOrType> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_condition_without_or_types`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_condition_without_or_types(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_condition_without_or_types(
+            visitor, self, __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <MediaConditionWithoutOrType as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <MediaConditionWithoutOrType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaQuery> {
-    #[doc = "Calls [Fold`::fold_media_querys`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaQuery> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_media_querys`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_media_querys(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_media_querys(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <MediaQuery as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <MediaQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<AtRulePrelude>> {
-    #[doc = "Calls [Fold`::fold_opt_at_rule_prelude`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<AtRulePrelude>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_at_rule_prelude`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_at_rule_prelude(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_at_rule_prelude(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<AtRulePrelude> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<AtRulePrelude> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [Fold`::fold_opt_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_atom(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<AttributeSelectorMatcher> {
-    #[doc = "Calls [Fold`::fold_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorMatcher> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_attribute_selector_matcher`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_attribute_selector_matcher(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_matcher(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <AttributeSelectorMatcher as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <AttributeSelectorMatcher as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<AttributeSelectorModifier> {
-    #[doc = "Calls [Fold`::fold_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorModifier> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_attribute_selector_modifier`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_attribute_selector_modifier(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_modifier(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <AttributeSelectorModifier as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <AttributeSelectorModifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<AttributeSelectorValue> {
-    #[doc = "Calls [Fold`::fold_opt_attribute_selector_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorValue> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_attribute_selector_value`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_attribute_selector_value(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_attribute_selector_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <AttributeSelectorValue as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <AttributeSelectorValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
-}
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Combinator> {
-    #[doc = "Calls [Fold`::fold_opt_combinator`] with `self`. (Extra impl)"]
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Combinator> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_combinator`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_combinator(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_combinator(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Combinator as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Combinator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<ContainerName> {
-    #[doc = "Calls [Fold`::fold_opt_container_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ContainerName> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_container_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_container_name(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_container_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <ContainerName as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <ContainerName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<ForgivingSelectorList> {
-    #[doc = "Calls [Fold`::fold_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ForgivingSelectorList> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_forgiving_selector_list`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_forgiving_selector_list(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_forgiving_selector_list(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <ForgivingSelectorList as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <ForgivingSelectorList as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Function>> {
-    #[doc = "Calls [Fold`::fold_opt_function`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Function>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_function`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_function(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_function(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<Function> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Ident> {
-    #[doc = "Calls [Fold`::fold_opt_ident`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Ident> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ident(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ident(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Ident as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<ImportConditions>> {
-    #[doc = "Calls [Fold`::fold_opt_import_conditions`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ImportConditions>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_import_conditions`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_import_conditions(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_import_conditions(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<ImportConditions> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Box<ImportConditions> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<ImportLayerName>> {
-    #[doc = "Calls [Fold`::fold_opt_import_layer_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ImportLayerName>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_import_layer_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_import_layer_name(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_import_layer_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<ImportLayerName> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Box<ImportLayerName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<ImportantFlag> {
-    #[doc = "Calls [Fold`::fold_opt_important_flag`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ImportantFlag> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_important_flag`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_important_flag(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_important_flag(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <ImportantFlag as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <ImportantFlag as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<MediaConditionType>> {
-    #[doc = "Calls [Fold`::fold_opt_media_condition_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<MediaConditionType>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_media_condition_type`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_media_condition_type(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_condition_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<MediaConditionType> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Box<MediaConditionType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<MediaQueryList>> {
-    #[doc = "Calls [Fold`::fold_opt_media_query_list`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<MediaQueryList>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_media_query_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_media_query_list(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_query_list(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<MediaQueryList> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Box<MediaQueryList> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<MediaType> {
-    #[doc = "Calls [Fold`::fold_opt_media_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<MediaType> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_media_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_media_type(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_media_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <MediaType as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <MediaType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Namespace> {
-    #[doc = "Calls [Fold`::fold_opt_namespace`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Namespace> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_namespace`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_namespace(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_namespace(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Namespace as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Namespace as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<NamespacePrefix> {
-    #[doc = "Calls [Fold`::fold_opt_namespace_prefix`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<NamespacePrefix> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_namespace_prefix`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_namespace_prefix(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_namespace_prefix(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <NamespacePrefix as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <NamespacePrefix as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<NestingSelector> {
-    #[doc = "Calls [Fold`::fold_opt_nesting_selector`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<NestingSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_nesting_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_nesting_selector(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_nesting_selector(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <NestingSelector as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <NestingSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Number> {
-    #[doc = "Calls [Fold`::fold_opt_number`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Number> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_number`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_number(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_number(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Number as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PageSelectorPseudo>> {
-    #[doc = "Calls [Fold`::fold_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<PageSelectorPseudo>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_page_selector_pseudos`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_page_selector_pseudos(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_page_selector_pseudos(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Vec<PageSelectorPseudo> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Vec<PageSelectorPseudo> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<PageSelectorType> {
-    #[doc = "Calls [Fold`::fold_opt_page_selector_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<PageSelectorType> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_page_selector_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_page_selector_type(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_page_selector_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <PageSelectorType as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <PageSelectorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
-    #[doc = "Calls [Fold`::fold_opt_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V>
+    for Option<Vec<PseudoClassSelectorChildren>>
+{
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_pseudo_class_selector_childrens`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_pseudo_class_selector_childrens(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_pseudo_class_selector_childrens(
+            visitor, self, __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| {
-            <Vec<PseudoClassSelectorChildren> as FoldWith<V>>::fold_with(inner, visitor)
-        })
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self { Some (inner) => { < Vec < PseudoClassSelectorChildren > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (inner , visitor , __ast_path) } None => { } }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
-    #[doc = "Calls [Fold`::fold_opt_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V>
+    for Option<Vec<PseudoElementSelectorChildren>>
+{
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_pseudo_element_selector_childrens`] with \
+             `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_pseudo_element_selector_childrens(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_pseudo_element_selector_childrens(
+            visitor, self, __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| {
-            <Vec<PseudoElementSelectorChildren> as FoldWith<V>>::fold_with(inner, visitor)
-        })
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self { Some (inner) => { < Vec < PseudoElementSelectorChildren > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (inner , visitor , __ast_path) } None => { } }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<SimpleBlock> {
-    #[doc = "Calls [Fold`::fold_opt_simple_block`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<SimpleBlock> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_simple_block`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_simple_block(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_simple_block(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <SimpleBlock as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <SimpleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TypeSelector>> {
-    #[doc = "Calls [Fold`::fold_opt_type_selector`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TypeSelector>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_type_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_type_selector(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_type_selector(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<TypeSelector> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<TypeSelector> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<UrlModifier>> {
-    #[doc = "Calls [Fold`::fold_opt_url_modifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<UrlModifier>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_url_modifiers(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_url_modifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Vec<UrlModifier> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Vec<UrlModifier> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<UrlValue>> {
-    #[doc = "Calls [Fold`::fold_opt_url_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<UrlValue>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_url_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_url_value(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_url_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<UrlValue> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<UrlValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelectorPseudo> {
-    #[doc = "Calls [Fold`::fold_page_selector_pseudos`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PageSelectorPseudo> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_page_selector_pseudos(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selector_pseudos(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <PageSelectorPseudo as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PageSelectorPseudo as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelector> {
-    #[doc = "Calls [Fold`::fold_page_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PageSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_page_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_page_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_page_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <PageSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PageSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<PseudoClassSelectorChildren> {
-    #[doc = "Calls [Fold`::fold_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoClassSelectorChildren> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_class_selector_childrens`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pseudo_class_selector_childrens(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_class_selector_childrens(visitor, self, __ast_path)
     }
 
-    #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <PseudoClassSelectorChildren as FoldWith<V>>::fold_with(item, visitor)
+    #[inline]
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PseudoClassSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<PseudoElementSelectorChildren> {
-    #[doc = "Calls [Fold`::fold_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoElementSelectorChildren> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pseudo_element_selector_childrens`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pseudo_element_selector_childrens(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pseudo_element_selector_childrens(
+            visitor, self, __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <PseudoElementSelectorChildren as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PseudoElementSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<RelativeSelector> {
-    #[doc = "Calls [Fold`::fold_relative_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<RelativeSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_relative_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_relative_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <RelativeSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <RelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Rule> {
-    #[doc = "Calls [Fold`::fold_rules`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Rule> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_rules`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_rules(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rules(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Rule as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Rule as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
-    #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::Span {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_span(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        {}
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<SubclassSelector> {
-    #[doc = "Calls [Fold`::fold_subclass_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SubclassSelector> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_subclass_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_subclass_selectors(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_subclass_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <SubclassSelector as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <SubclassSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<SupportsConditionType> {
-    #[doc = "Calls [Fold`::fold_supports_condition_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SupportsConditionType> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_supports_condition_types`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_supports_condition_types(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_supports_condition_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <SupportsConditionType as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <SupportsConditionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<UrlModifier> {
-    #[doc = "Calls [Fold`::fold_url_modifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<UrlModifier> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_url_modifiers(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_url_modifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <UrlModifier as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <UrlModifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V, T> FoldWith<V> for std::boxed::Box<T>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> VisitMutWithAstPath<V> for std::boxed::Box<T>
 where
-    V: ?Sized + Fold,
-    T: FoldWith<V>,
+    V: ?Sized + VisitMutAstPath,
+    T: VisitMutWithAstPath<V>,
 {
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::map::Map::map(self, |inner| <T as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        let v = <T as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+            &mut **self,
+            visitor,
+            __ast_path,
+        );
+        v
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::map::Map::map(self, |inner| {
-            <T as FoldWith<V>>::fold_children_with(inner, visitor)
-        })
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        let v = <T as VisitMutWithAstPath<V>>::visit_mut_children_with_ast_path(
+            &mut **self,
+            visitor,
+            __ast_path,
+        );
+        v
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait FoldAstPath {
+pub trait Fold {
     #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
-             [`AbsoluteColorBase::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AbsoluteColorBase::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_absolute_color_base(
-        &mut self,
-        node: AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) -> AbsoluteColorBase {
-        <AbsoluteColorBase as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
+        <AbsoluteColorBase as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
-             [`AlphaValue::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AlphaValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
-        <AlphaValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
+        <AlphaValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
-             [`AnPlusB::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AnPlusB::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
-        <AnPlusB as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
+        <AnPlusB as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
-             [`AnPlusBNotation::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AnPlusBNotation::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_an_plus_b_notation(
-        &mut self,
-        node: AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) -> AnPlusBNotation {
-        <AnPlusBNotation as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
+        <AnPlusBNotation as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
-             [`Angle::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Angle::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
-        <Angle as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_angle(&mut self, node: Angle) -> Angle {
+        <Angle as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
-             [`AnglePercentage::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AnglePercentage::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_angle_percentage(
-        &mut self,
-        node: AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> AnglePercentage {
-        <AnglePercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
+        <AnglePercentage as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
-             [`AnyNamespace::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AnyNamespace::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_any_namespace(
-        &mut self,
-        node: AnyNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> AnyNamespace {
-        <AnyNamespace as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
+        <AnyNamespace as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
-             [`AtRule::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AtRule::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
-        <AtRule as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
+        <AtRule as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
-             [`AtRuleName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AtRuleName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
-        <AtRuleName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
+        <AtRuleName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
-             [`AtRulePrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AtRulePrelude::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_at_rule_prelude(
-        &mut self,
-        node: AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> AtRulePrelude {
-        <AtRulePrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
+        <AtRulePrelude as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`swc_atoms :: Atom::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
-        <swc_atoms::Atom as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+        <swc_atoms::Atom as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
-             [`AttributeSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AttributeSelector::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_attribute_selector(
-        &mut self,
-        node: AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> AttributeSelector {
-        <AttributeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
+        <AttributeSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
-             [`AttributeSelectorMatcher::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`AttributeSelectorMatcher::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_attribute_selector_matcher(
         &mut self,
         node: AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcher {
-        <AttributeSelectorMatcher as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <AttributeSelectorMatcher as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
-             calls [`AttributeSelectorMatcherValue::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`AttributeSelectorMatcherValue::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
     fn fold_attribute_selector_matcher_value(
         &mut self,
         node: AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcherValue {
-        <AttributeSelectorMatcherValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <AttributeSelectorMatcherValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
-             [`AttributeSelectorModifier::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`AttributeSelectorModifier::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_attribute_selector_modifier(
         &mut self,
         node: AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorModifier {
-        <AttributeSelectorModifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <AttributeSelectorModifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
-             [`AttributeSelectorValue::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`AttributeSelectorValue::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_attribute_selector_value(
         &mut self,
         node: AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorValue {
-        <AttributeSelectorValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <AttributeSelectorValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
-             [`BinOp::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BinOp::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
-        <BinOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
+        <BinOp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
-             [`CalcOperator::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CalcOperator::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_calc_operator(
-        &mut self,
-        node: CalcOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperator {
-        <CalcOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
+        <CalcOperator as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
-             [`CalcOperatorType::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CalcOperatorType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_calc_operator_type(
-        &mut self,
-        node: CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperatorType {
-        <CalcOperatorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
+        <CalcOperatorType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
-             [`CalcProduct::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CalcProduct::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_calc_product(
-        &mut self,
-        node: CalcProduct,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcProduct {
-        <CalcProduct as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
+        <CalcProduct as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
-             [`CalcProductOrOperator::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CalcProductOrOperator::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_calc_product_or_operator(
         &mut self,
         node: CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
     ) -> CalcProductOrOperator {
-        <CalcProductOrOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <CalcProductOrOperator as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
-             calls [`Vec < CalcProductOrOperator >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < CalcProductOrOperator >::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
     fn fold_calc_product_or_operators(
         &mut self,
         node: Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcProductOrOperator> {
-        <Vec<CalcProductOrOperator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<CalcProductOrOperator> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
-             [`CalcSum::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CalcSum::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
-        <CalcSum as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
+        <CalcSum as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
-             [`CalcValue::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`CalcValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
-        <CalcValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
+        <CalcValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
-             [`CalcValueOrOperator::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CalcValueOrOperator::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_calc_value_or_operator(
-        &mut self,
-        node: CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcValueOrOperator {
-        <CalcValueOrOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
+        <CalcValueOrOperator as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
-             [`Vec < CalcValueOrOperator >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < CalcValueOrOperator >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_calc_value_or_operators(
         &mut self,
         node: Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcValueOrOperator> {
-        <Vec<CalcValueOrOperator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<CalcValueOrOperator> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
-             [`ClassSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ClassSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_class_selector(
-        &mut self,
-        node: ClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassSelector {
-        <ClassSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
+        <ClassSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
-             [`CmykComponent::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CmykComponent::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_cmyk_component(
-        &mut self,
-        node: CmykComponent,
-        __ast_path: &mut AstKindPath,
-    ) -> CmykComponent {
-        <CmykComponent as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
+        <CmykComponent as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
-             [`Color::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Color::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
-        <Color as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_color(&mut self, node: Color) -> Color {
+        <Color as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
-             [`ColorProfileName::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ColorProfileName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_color_profile_name(
-        &mut self,
-        node: ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) -> ColorProfileName {
-        <ColorProfileName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
+        <ColorProfileName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
-             [`Combinator::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Combinator::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
-        <Combinator as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
+        <Combinator as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
-             [`CombinatorValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CombinatorValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_combinator_value(
-        &mut self,
-        node: CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) -> CombinatorValue {
-        <CombinatorValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
+        <CombinatorValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
-             [`ComplexSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ComplexSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_complex_selector(
-        &mut self,
-        node: ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ComplexSelector {
-        <ComplexSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
+        <ComplexSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
-             [`ComplexSelectorChildren::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ComplexSelectorChildren::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_complex_selector_children(
         &mut self,
         node: ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> ComplexSelectorChildren {
-        <ComplexSelectorChildren as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ComplexSelectorChildren as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
-             calls [`Vec < ComplexSelectorChildren >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Vec < ComplexSelectorChildren >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_complex_selector_childrens(
         &mut self,
         node: Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ComplexSelectorChildren> {
-        <Vec<ComplexSelectorChildren> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<ComplexSelectorChildren> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
-             [`Vec < ComplexSelector >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < ComplexSelector >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_complex_selectors(
-        &mut self,
-        node: Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComplexSelector> {
-        <Vec<ComplexSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
+        <Vec<ComplexSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
-             [`ComponentValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ComponentValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_component_value(
-        &mut self,
-        node: ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) -> ComponentValue {
-        <ComponentValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
+        <ComponentValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
-             < ComponentValue >::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             < ComponentValue >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_component_values(
-        &mut self,
-        node: Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComponentValue> {
-        <Vec<ComponentValue> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
+        <Vec<ComponentValue> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
-             [`CompoundSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CompoundSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_compound_selector(
-        &mut self,
-        node: CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelector {
-        <CompoundSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
+        <CompoundSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
-             [`CompoundSelectorList::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CompoundSelectorList::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_compound_selector_list(
-        &mut self,
-        node: CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelectorList {
-        <CompoundSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
+        <CompoundSelectorList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
-             [`Vec < CompoundSelector >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < CompoundSelector >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_compound_selectors(
-        &mut self,
-        node: Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CompoundSelector> {
-        <Vec<CompoundSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
+        <Vec<CompoundSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
-             [`ContainerCondition::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ContainerCondition::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_container_condition(
-        &mut self,
-        node: ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerCondition {
-        <ContainerCondition as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
+        <ContainerCondition as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
-             [`ContainerName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ContainerName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_container_name(
-        &mut self,
-        node: ContainerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerName {
-        <ContainerName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
+        <ContainerName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
-             [`ContainerQuery::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ContainerQuery::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_container_query(
-        &mut self,
-        node: ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQuery {
-        <ContainerQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
+        <ContainerQuery as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
-             [`ContainerQueryAnd::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ContainerQueryAnd::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_container_query_and(
-        &mut self,
-        node: ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryAnd {
-        <ContainerQueryAnd as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
+        <ContainerQueryAnd as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
-             [`ContainerQueryNot::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ContainerQueryNot::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_container_query_not(
-        &mut self,
-        node: ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryNot {
-        <ContainerQueryNot as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
+        <ContainerQueryNot as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
-             [`ContainerQueryOr::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ContainerQueryOr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_container_query_or(
-        &mut self,
-        node: ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryOr {
-        <ContainerQueryOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
+        <ContainerQueryOr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
-             [`ContainerQueryType::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ContainerQueryType::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_container_query_type(
-        &mut self,
-        node: ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryType {
-        <ContainerQueryType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
+        <ContainerQueryType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
-             [`Vec < ContainerQueryType >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < ContainerQueryType >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_container_query_types(
         &mut self,
         node: Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ContainerQueryType> {
-        <Vec<ContainerQueryType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<ContainerQueryType> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
-             [`CustomHighlightName::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`CustomHighlightName::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_custom_highlight_name(
-        &mut self,
-        node: CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomHighlightName {
-        <CustomHighlightName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
+        <CustomHighlightName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
-             [`CustomIdent::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CustomIdent::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_custom_ident(
-        &mut self,
-        node: CustomIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomIdent {
-        <CustomIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
+        <CustomIdent as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
-             CustomIdent >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             CustomIdent >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_custom_idents(
-        &mut self,
-        node: Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CustomIdent> {
-        <Vec<CustomIdent> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
+        <Vec<CustomIdent> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
-             [`CustomMediaQuery::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CustomMediaQuery::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_custom_media_query(
-        &mut self,
-        node: CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomMediaQuery {
-        <CustomMediaQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
+        <CustomMediaQuery as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
-             [`CustomMediaQueryMediaType::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`CustomMediaQueryMediaType::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_custom_media_query_media_type(
         &mut self,
         node: CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
     ) -> CustomMediaQueryMediaType {
-        <CustomMediaQueryMediaType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <CustomMediaQueryMediaType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
-             [`CustomPropertyName::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CustomPropertyName::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_custom_property_name(
-        &mut self,
-        node: CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomPropertyName {
-        <CustomPropertyName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
+        <CustomPropertyName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
-             [`DashedIdent::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DashedIdent::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_dashed_ident(
-        &mut self,
-        node: DashedIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> DashedIdent {
-        <DashedIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
+        <DashedIdent as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
-             [`Declaration::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Declaration::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
-        <Declaration as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
+        <Declaration as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
-             [`DeclarationName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DeclarationName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_declaration_name(
-        &mut self,
-        node: DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationName {
-        <DeclarationName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
+        <DeclarationName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
-             [`DeclarationOrAtRule::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`DeclarationOrAtRule::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_declaration_or_at_rule(
-        &mut self,
-        node: DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationOrAtRule {
-        <DeclarationOrAtRule as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
+        <DeclarationOrAtRule as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
-             [`Delimiter::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Delimiter::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
-        <Delimiter as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
+        <Delimiter as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
-             [`DelimiterValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DelimiterValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_delimiter_value(
-        &mut self,
-        node: DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) -> DelimiterValue {
-        <DelimiterValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
+        <DelimiterValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
-             [`Dimension::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Dimension::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
-        <Dimension as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
+        <Dimension as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
-             [`DimensionToken::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DimensionToken::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_dimension_token(
-        &mut self,
-        node: DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) -> DimensionToken {
-        <DimensionToken as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
+        <DimensionToken as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
-             [`DocumentPrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DocumentPrelude::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_document_prelude(
-        &mut self,
-        node: DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> DocumentPrelude {
-        <DocumentPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
+        <DocumentPrelude as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
-             calls [`DocumentPreludeMatchingFunction::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`DocumentPreludeMatchingFunction::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_document_prelude_matching_function(
         &mut self,
         node: DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) -> DocumentPreludeMatchingFunction {
-        <DocumentPreludeMatchingFunction as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <DocumentPreludeMatchingFunction as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
-             method calls [`Vec < DocumentPreludeMatchingFunction \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             method calls [`Vec < DocumentPreludeMatchingFunction >::fold_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn fold_document_prelude_matching_functions(
         &mut self,
         node: Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<DocumentPreludeMatchingFunction> {
-        <Vec<DocumentPreludeMatchingFunction> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<DocumentPreludeMatchingFunction> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
-             [`ExtensionName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExtensionName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_extension_name(
-        &mut self,
-        node: ExtensionName,
-        __ast_path: &mut AstKindPath,
-    ) -> ExtensionName {
-        <ExtensionName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
+        <ExtensionName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
-             [`FamilyName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`FamilyName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
-        <FamilyName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
+        <FamilyName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
-             FamilyName >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             FamilyName >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_family_names(
-        &mut self,
-        node: Vec<FamilyName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<FamilyName> {
-        <Vec<FamilyName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
+        <Vec<FamilyName> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
-             [`Flex::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Flex::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
-        <Flex as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_flex(&mut self, node: Flex) -> Flex {
+        <Flex as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
-             [`FontFeatureValuesPrelude::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`FontFeatureValuesPrelude::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_font_feature_values_prelude(
         &mut self,
         node: FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
     ) -> FontFeatureValuesPrelude {
-        <FontFeatureValuesPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <FontFeatureValuesPrelude as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
-             [`ForgivingComplexSelector::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ForgivingComplexSelector::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_forgiving_complex_selector(
         &mut self,
         node: ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingComplexSelector {
-        <ForgivingComplexSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ForgivingComplexSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingComplexSelector >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Vec < ForgivingComplexSelector >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_forgiving_complex_selectors(
         &mut self,
         node: Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingComplexSelector> {
-        <Vec<ForgivingComplexSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<ForgivingComplexSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
-    #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
-             [`ForgivingRelativeSelector::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+    #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
+             [`ForgivingRelativeSelector::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_forgiving_relative_selector(
         &mut self,
         node: ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelector {
-        <ForgivingRelativeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ForgivingRelativeSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
-             calls [`ForgivingRelativeSelectorList::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`ForgivingRelativeSelectorList::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
     fn fold_forgiving_relative_selector_list(
         &mut self,
         node: ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelectorList {
-        <ForgivingRelativeSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ForgivingRelativeSelectorList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingRelativeSelector >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Vec < ForgivingRelativeSelector >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_forgiving_relative_selectors(
         &mut self,
         node: Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingRelativeSelector> {
-        <Vec<ForgivingRelativeSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<ForgivingRelativeSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
-             [`ForgivingSelectorList::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ForgivingSelectorList::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_forgiving_selector_list(
         &mut self,
         node: ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingSelectorList {
-        <ForgivingSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ForgivingSelectorList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
-             [`Frequency::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Frequency::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
-        <Frequency as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
+        <Frequency as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
-             [`FrequencyPercentage::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`FrequencyPercentage::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_frequency_percentage(
-        &mut self,
-        node: FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> FrequencyPercentage {
-        <FrequencyPercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
+        <FrequencyPercentage as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Function::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
-        <Function as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_function(&mut self, node: Function) -> Function {
+        <Function as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
-             [`FunctionName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`FunctionName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_function_name(
-        &mut self,
-        node: FunctionName,
-        __ast_path: &mut AstKindPath,
-    ) -> FunctionName {
-        <FunctionName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
+        <FunctionName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
-             [`GeneralEnclosed::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`GeneralEnclosed::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_general_enclosed(
-        &mut self,
-        node: GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) -> GeneralEnclosed {
-        <GeneralEnclosed as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
+        <GeneralEnclosed as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
-             [`HexColor::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`HexColor::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
-        <HexColor as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
+        <HexColor as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
-             [`Hue::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Hue::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
-        <Hue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_hue(&mut self, node: Hue) -> Hue {
+        <Hue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
-             [`IdSelector::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`IdSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
-        <IdSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
+        <IdSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Ident::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
-        <Ident as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ident(&mut self, node: Ident) -> Ident {
+        <Ident as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
-        <Vec<Ident> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
+        <Vec<Ident> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
-             [`ImportConditions::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ImportConditions::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_conditions(
-        &mut self,
-        node: ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportConditions {
-        <ImportConditions as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
+        <ImportConditions as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
-             [`ImportHref::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ImportHref::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
-        <ImportHref as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
+        <ImportHref as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
-             [`ImportLayerName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportLayerName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_layer_name(
-        &mut self,
-        node: ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportLayerName {
-        <ImportLayerName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
+        <ImportLayerName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
-             [`ImportPrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportPrelude::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_prelude(
-        &mut self,
-        node: ImportPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPrelude {
-        <ImportPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
+        <ImportPrelude as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
-             [`ImportantFlag::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportantFlag::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_important_flag(
-        &mut self,
-        node: ImportantFlag,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportantFlag {
-        <ImportantFlag as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
+        <ImportantFlag as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
-             [`Integer::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Integer::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
-        <Integer as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_integer(&mut self, node: Integer) -> Integer {
+        <Integer as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
-             [`KeyframeBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`KeyframeBlock::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_keyframe_block(
-        &mut self,
-        node: KeyframeBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeBlock {
-        <KeyframeBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
+        <KeyframeBlock as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
-             [`KeyframeSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`KeyframeSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_keyframe_selector(
-        &mut self,
-        node: KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeSelector {
-        <KeyframeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
+        <KeyframeSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
-             [`Vec < KeyframeSelector >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < KeyframeSelector >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_keyframe_selectors(
-        &mut self,
-        node: Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<KeyframeSelector> {
-        <Vec<KeyframeSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
+        <Vec<KeyframeSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
-             [`KeyframesName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`KeyframesName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_keyframes_name(
-        &mut self,
-        node: KeyframesName,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframesName {
-        <KeyframesName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
+        <KeyframesName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
-             [`KeyframesPseudoFunction::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`KeyframesPseudoFunction::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_keyframes_pseudo_function(
         &mut self,
         node: KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoFunction {
-        <KeyframesPseudoFunction as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <KeyframesPseudoFunction as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
-             [`KeyframesPseudoPrefix::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`KeyframesPseudoPrefix::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_keyframes_pseudo_prefix(
         &mut self,
         node: KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoPrefix {
-        <KeyframesPseudoPrefix as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <KeyframesPseudoPrefix as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
-             [`LayerName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`LayerName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
-        <LayerName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
+        <LayerName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
-             [`LayerNameList::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`LayerNameList::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_layer_name_list(
-        &mut self,
-        node: LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerNameList {
-        <LayerNameList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
+        <LayerNameList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
-             LayerName >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             LayerName >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_layer_names(
-        &mut self,
-        node: Vec<LayerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<LayerName> {
-        <Vec<LayerName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
+        <Vec<LayerName> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
-             [`LayerPrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`LayerPrelude::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_layer_prelude(
-        &mut self,
-        node: LayerPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerPrelude {
-        <LayerPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
+        <LayerPrelude as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
-             [`Length::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Length::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
-        <Length as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_length(&mut self, node: Length) -> Length {
+        <Length as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
-             [`LengthPercentage::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`LengthPercentage::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_length_percentage(
-        &mut self,
-        node: LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> LengthPercentage {
-        <LengthPercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
+        <LengthPercentage as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
-             [`ListOfComponentValues::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ListOfComponentValues::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_list_of_component_values(
         &mut self,
         node: ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
     ) -> ListOfComponentValues {
-        <ListOfComponentValues as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ListOfComponentValues as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
-             [`MediaAnd::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaAnd::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
-        <MediaAnd as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
+        <MediaAnd as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
-             [`MediaCondition::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaCondition::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_condition(
-        &mut self,
-        node: MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaCondition {
-        <MediaCondition as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
+        <MediaCondition as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
-             [`MediaConditionAllType::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaConditionAllType::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_media_condition_all_type(
         &mut self,
         node: MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionAllType {
-        <MediaConditionAllType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <MediaConditionAllType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
-             calls [`Vec < MediaConditionAllType >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < MediaConditionAllType >::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
     fn fold_media_condition_all_types(
         &mut self,
         node: Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionAllType> {
-        <Vec<MediaConditionAllType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<MediaConditionAllType> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
-             [`MediaConditionType::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaConditionType::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_media_condition_type(
-        &mut self,
-        node: MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaConditionType {
-        <MediaConditionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
+        <MediaConditionType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOr::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaConditionWithoutOr::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_media_condition_without_or(
         &mut self,
         node: MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOr {
-        <MediaConditionWithoutOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <MediaConditionWithoutOr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOrType::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`MediaConditionWithoutOrType::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_media_condition_without_or_type(
         &mut self,
         node: MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOrType {
-        <MediaConditionWithoutOrType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <MediaConditionWithoutOrType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
-             method calls [`Vec < MediaConditionWithoutOrType >::fold_children_with_ast_path`]. If \
-             you want to recurse, you need to call it manually."]
+             method calls [`Vec < MediaConditionWithoutOrType >::fold_children_with`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
     fn fold_media_condition_without_or_types(
         &mut self,
         node: Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionWithoutOrType> {
-        <Vec<MediaConditionWithoutOrType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<MediaConditionWithoutOrType> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
-             [`MediaFeature::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaFeature::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_feature(
-        &mut self,
-        node: MediaFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeature {
-        <MediaFeature as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
+        <MediaFeature as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
-             [`MediaFeatureBoolean::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`MediaFeatureBoolean::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_media_feature_boolean(
-        &mut self,
-        node: MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureBoolean {
-        <MediaFeatureBoolean as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
+        <MediaFeatureBoolean as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
-             [`MediaFeatureName::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaFeatureName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_feature_name(
-        &mut self,
-        node: MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureName {
-        <MediaFeatureName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
+        <MediaFeatureName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
-             [`MediaFeaturePlain::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaFeaturePlain::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_media_feature_plain(
-        &mut self,
-        node: MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeaturePlain {
-        <MediaFeaturePlain as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
+        <MediaFeaturePlain as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
-             [`MediaFeatureRange::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaFeatureRange::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_media_feature_range(
-        &mut self,
-        node: MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureRange {
-        <MediaFeatureRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
+        <MediaFeatureRange as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeComparison::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`MediaFeatureRangeComparison::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_media_feature_range_comparison(
         &mut self,
         node: MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeComparison {
-        <MediaFeatureRangeComparison as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <MediaFeatureRangeComparison as FoldWith<Self>>::fold_children_with(node, self)
     }
-    #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeInterval::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+    #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
+             [`MediaFeatureRangeInterval::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_media_feature_range_interval(
         &mut self,
         node: MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeInterval {
-        <MediaFeatureRangeInterval as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <MediaFeatureRangeInterval as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
-             [`MediaFeatureValue::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MediaFeatureValue::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_media_feature_value(
-        &mut self,
-        node: MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureValue {
-        <MediaFeatureValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
+        <MediaFeatureValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
-             [`MediaInParens::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaInParens::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_in_parens(
-        &mut self,
-        node: MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaInParens {
-        <MediaInParens as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
+        <MediaInParens as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
-             [`MediaNot::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaNot::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
-        <MediaNot as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
+        <MediaNot as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
-             [`MediaOr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MediaOr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
-        <MediaOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
+        <MediaOr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
-             [`MediaQuery::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaQuery::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
-        <MediaQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
+        <MediaQuery as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
-             [`MediaQueryList::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MediaQueryList::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_query_list(
-        &mut self,
-        node: MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaQueryList {
-        <MediaQueryList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
+        <MediaQueryList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
-             MediaQuery >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             MediaQuery >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_querys(
-        &mut self,
-        node: Vec<MediaQuery>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<MediaQuery> {
-        <Vec<MediaQuery> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
+        <Vec<MediaQuery> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
-             [`MediaType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MediaType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
-        <MediaType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
+        <MediaType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
-             [`NamedNamespace::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`NamedNamespace::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_named_namespace(
-        &mut self,
-        node: NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedNamespace {
-        <NamedNamespace as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
+        <NamedNamespace as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Namespace::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
-        <Namespace as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
+        <Namespace as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
-             [`NamespacePrefix::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`NamespacePrefix::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_namespace_prefix(
-        &mut self,
-        node: NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrefix {
-        <NamespacePrefix as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
+        <NamespacePrefix as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
-             [`NamespacePrelude::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`NamespacePrelude::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_namespace_prelude(
-        &mut self,
-        node: NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrelude {
-        <NamespacePrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
+        <NamespacePrelude as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
-             [`NamespacePreludeUri::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`NamespacePreludeUri::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_namespace_prelude_uri(
-        &mut self,
-        node: NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePreludeUri {
-        <NamespacePreludeUri as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
+        <NamespacePreludeUri as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
-             [`NestingSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`NestingSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_nesting_selector(
-        &mut self,
-        node: NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> NestingSelector {
-        <NestingSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
+        <NestingSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Number::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
-        <Number as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_number(&mut self, node: Number) -> Number {
+        <Number as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
-             [`NumberType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`NumberType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
-        <NumberType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
+        <NumberType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
-             calls [`Option < Box < AtRulePrelude > >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Option < Box < AtRulePrelude > >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_at_rule_prelude(
         &mut self,
         node: Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<AtRulePrelude>> {
-        <Option<Box<AtRulePrelude>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Box<AtRulePrelude>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < swc_atoms :: Atom >::fold_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
-        <Option<swc_atoms::Atom> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+        <Option<swc_atoms::Atom> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorMatcher >::fold_children_with_ast_path`]. If \
-             you want to recurse, you need to call it manually."]
+             method calls [`Option < AttributeSelectorMatcher >::fold_children_with`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_attribute_selector_matcher(
         &mut self,
         node: Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorMatcher> {
-        <Option<AttributeSelectorMatcher> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<AttributeSelectorMatcher> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorModifier >::fold_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
+             method calls [`Option < AttributeSelectorModifier >::fold_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_attribute_selector_modifier(
         &mut self,
         node: Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorModifier> {
-        <Option<AttributeSelectorModifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<AttributeSelectorModifier> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
-             calls [`Option < AttributeSelectorValue >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Option < AttributeSelectorValue >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_attribute_selector_value(
         &mut self,
         node: Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorValue> {
-        <Option<AttributeSelectorValue> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<AttributeSelectorValue> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
-             [`Option < Combinator >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Combinator >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_combinator(
-        &mut self,
-        node: Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Combinator> {
-        <Option<Combinator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
+        <Option<Combinator> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
-             [`Option < ContainerName >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < ContainerName >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_container_name(
-        &mut self,
-        node: Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ContainerName> {
-        <Option<ContainerName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
+        <Option<ContainerName> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
-             calls [`Option < ForgivingSelectorList >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Option < ForgivingSelectorList >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_forgiving_selector_list(
         &mut self,
         node: Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ForgivingSelectorList> {
-        <Option<ForgivingSelectorList> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<ForgivingSelectorList> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
-             [`Option < Box < Function > >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Box < Function > >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_opt_function(
-        &mut self,
-        node: Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Function>> {
-        <Option<Box<Function>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
+        <Option<Box<Function>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             Ident >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
-        <Option<Ident> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+        <Option<Ident> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
-             method calls [`Option < Box < ImportConditions > >::fold_children_with_ast_path`]. If \
-             you want to recurse, you need to call it manually."]
+             method calls [`Option < Box < ImportConditions > >::fold_children_with`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_import_conditions(
         &mut self,
         node: Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportConditions>> {
-        <Option<Box<ImportConditions>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Box<ImportConditions>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
-             calls [`Option < Box < ImportLayerName > >::fold_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < Box < ImportLayerName > >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_import_layer_name(
         &mut self,
         node: Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportLayerName>> {
-        <Option<Box<ImportLayerName>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Box<ImportLayerName>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
-             [`Option < ImportantFlag >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < ImportantFlag >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_important_flag(
-        &mut self,
-        node: Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ImportantFlag> {
-        <Option<ImportantFlag> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
+        <Option<ImportantFlag> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
-             method calls [`Option < Box < MediaConditionType > >::fold_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
+             method calls [`Option < Box < MediaConditionType > >::fold_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_media_condition_type(
         &mut self,
         node: Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaConditionType>> {
-        <Option<Box<MediaConditionType>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Box<MediaConditionType>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
-             calls [`Option < Box < MediaQueryList > >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Option < Box < MediaQueryList > >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_media_query_list(
         &mut self,
         node: Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaQueryList>> {
-        <Option<Box<MediaQueryList>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Box<MediaQueryList>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
-             [`Option < MediaType >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < MediaType >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_media_type(
-        &mut self,
-        node: Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<MediaType> {
-        <Option<MediaType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
+        <Option<MediaType> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Namespace >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_namespace(
-        &mut self,
-        node: Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Namespace> {
-        <Option<Namespace> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
+        <Option<Namespace> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
-             [`Option < NamespacePrefix >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < NamespacePrefix >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_opt_namespace_prefix(
         &mut self,
         node: Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NamespacePrefix> {
-        <Option<NamespacePrefix> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<NamespacePrefix> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
-             [`Option < NestingSelector >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < NestingSelector >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_opt_nesting_selector(
         &mut self,
         node: Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NestingSelector> {
-        <Option<NestingSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<NestingSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
-             Number >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             Number >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_number(
-        &mut self,
-        node: Option<Number>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Number> {
-        <Option<Number> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
+        <Option<Number> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
-             method calls [`Option < Vec < PageSelectorPseudo > >::fold_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
+             method calls [`Option < Vec < PageSelectorPseudo > >::fold_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_page_selector_pseudos(
         &mut self,
         node: Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PageSelectorPseudo>> {
-        <Option<Vec<PageSelectorPseudo>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Vec<PageSelectorPseudo>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
-             [`Option < PageSelectorType >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < PageSelectorType >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_opt_page_selector_type(
         &mut self,
         node: Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<PageSelectorType> {
-        <Option<PageSelectorType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<PageSelectorType> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
              this method calls [`Option < Vec < PseudoClassSelectorChildren > \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoClassSelectorChildren>> {
-        < Option < Vec < PseudoClassSelectorChildren > > as FoldWithAstPath < Self > > :: fold_children_with_ast_path (node , self , __ast_path)
+        <Option<Vec<PseudoClassSelectorChildren>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
              default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoElementSelectorChildren>> {
-        < Option < Vec < PseudoElementSelectorChildren > > as FoldWithAstPath < Self > > :: fold_children_with_ast_path (node , self , __ast_path)
+        <Option<Vec<PseudoElementSelectorChildren>> as FoldWith<Self>>::fold_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
-             [`Option < SimpleBlock >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < SimpleBlock >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_simple_block(
-        &mut self,
-        node: Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<SimpleBlock> {
-        <Option<SimpleBlock> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
+        <Option<SimpleBlock> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
-             calls [`Option < Box < TypeSelector > >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Option < Box < TypeSelector > >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_type_selector(
         &mut self,
         node: Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TypeSelector>> {
-        <Option<Box<TypeSelector>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Box<TypeSelector>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
-             calls [`Option < Vec < UrlModifier > >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Vec < UrlModifier > >::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
     fn fold_opt_url_modifiers(
         &mut self,
         node: Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<UrlModifier>> {
-        <Option<Vec<UrlModifier>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Vec<UrlModifier>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
-             [`Option < Box < UrlValue > >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Box < UrlValue > >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_opt_url_value(
-        &mut self,
-        node: Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<UrlValue>> {
-        <Option<Box<UrlValue>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
+        <Option<Box<UrlValue>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
-             [`PageSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`PageSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_page_selector(
-        &mut self,
-        node: PageSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelector {
-        <PageSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
+        <PageSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
-             [`PageSelectorList::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn fold_page_selector_list(
-        &mut self,
-        node: PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorList {
-        <PageSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+             [`PageSelectorList::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
+    #[inline]
+    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
+        <PageSelectorList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
-             [`PageSelectorPseudo::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PageSelectorPseudo::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_page_selector_pseudo(
-        &mut self,
-        node: PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorPseudo {
-        <PageSelectorPseudo as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
+        <PageSelectorPseudo as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
-             [`Vec < PageSelectorPseudo >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < PageSelectorPseudo >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_page_selector_pseudos(
         &mut self,
         node: Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PageSelectorPseudo> {
-        <Vec<PageSelectorPseudo> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<PageSelectorPseudo> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
-             [`PageSelectorType::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PageSelectorType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_page_selector_type(
-        &mut self,
-        node: PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorType {
-        <PageSelectorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
+        <PageSelectorType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
-             PageSelector >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             PageSelector >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_page_selectors(
-        &mut self,
-        node: Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PageSelector> {
-        <Vec<PageSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
+        <Vec<PageSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
-             [`Percentage::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Percentage::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
-        <Percentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
+        <Percentage as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
-             [`PseudoClassSelector::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`PseudoClassSelector::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_pseudo_class_selector(
-        &mut self,
-        node: PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PseudoClassSelector {
-        <PseudoClassSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
+        <PseudoClassSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
-             [`PseudoClassSelectorChildren::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`PseudoClassSelectorChildren::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_pseudo_class_selector_children(
         &mut self,
         node: PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoClassSelectorChildren {
-        <PseudoClassSelectorChildren as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <PseudoClassSelectorChildren as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoClassSelectorChildren >::fold_children_with_ast_path`]. If \
-             you want to recurse, you need to call it manually."]
+             method calls [`Vec < PseudoClassSelectorChildren >::fold_children_with`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
     fn fold_pseudo_class_selector_childrens(
         &mut self,
         node: Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoClassSelectorChildren> {
-        <Vec<PseudoClassSelectorChildren> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<PseudoClassSelectorChildren> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
-             [`PseudoElementSelector::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`PseudoElementSelector::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_pseudo_element_selector(
         &mut self,
         node: PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelector {
-        <PseudoElementSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <PseudoElementSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
-             calls [`PseudoElementSelectorChildren::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`PseudoElementSelectorChildren::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
     fn fold_pseudo_element_selector_children(
         &mut self,
         node: PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelectorChildren {
-        <PseudoElementSelectorChildren as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <PseudoElementSelectorChildren as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoElementSelectorChildren >::fold_children_with_ast_path`]. \
-             If you want to recurse, you need to call it manually."]
+             method calls [`Vec < PseudoElementSelectorChildren >::fold_children_with`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
     fn fold_pseudo_element_selector_childrens(
         &mut self,
         node: Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoElementSelectorChildren> {
-        <Vec<PseudoElementSelectorChildren> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<PseudoElementSelectorChildren> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
-             [`QualifiedRule::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`QualifiedRule::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_qualified_rule(
-        &mut self,
-        node: QualifiedRule,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRule {
-        <QualifiedRule as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
+        <QualifiedRule as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
-             [`QualifiedRulePrelude::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`QualifiedRulePrelude::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_qualified_rule_prelude(
-        &mut self,
-        node: QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRulePrelude {
-        <QualifiedRulePrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
+        <QualifiedRulePrelude as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
-             [`QueryInParens::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`QueryInParens::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_query_in_parens(
-        &mut self,
-        node: QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> QueryInParens {
-        <QueryInParens as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
+        <QueryInParens as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
-             [`Ratio::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Ratio::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
-        <Ratio as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
+        <Ratio as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
-             [`RelativeSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`RelativeSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_relative_selector(
-        &mut self,
-        node: RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelector {
-        <RelativeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
+        <RelativeSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
-             [`RelativeSelectorList::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`RelativeSelectorList::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_relative_selector_list(
-        &mut self,
-        node: RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelectorList {
-        <RelativeSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
+        <RelativeSelectorList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
-             [`Vec < RelativeSelector >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < RelativeSelector >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_relative_selectors(
-        &mut self,
-        node: Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<RelativeSelector> {
-        <Vec<RelativeSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
+        <Vec<RelativeSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
-             [`Resolution::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Resolution::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
-        <Resolution as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
+        <Resolution as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
-             [`Rule::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Rule::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
-        <Rule as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_rule(&mut self, node: Rule) -> Rule {
+        <Rule as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
-        <Vec<Rule> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
+        <Vec<Rule> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
-             [`ScopeRange::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ScopeRange::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
-        <ScopeRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
+        <ScopeRange as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
-             [`SelectorList::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SelectorList::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_selector_list(
-        &mut self,
-        node: SelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> SelectorList {
-        <SelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
+        <SelectorList as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
-             [`SequenceOfCustomIdents::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SequenceOfCustomIdents::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_sequence_of_custom_idents(
         &mut self,
         node: SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
     ) -> SequenceOfCustomIdents {
-        <SequenceOfCustomIdents as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <SequenceOfCustomIdents as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
-             [`SimpleBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SimpleBlock::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_simple_block(
-        &mut self,
-        node: SimpleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleBlock {
-        <SimpleBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
+        <SimpleBlock as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
-             [`SizeFeature::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SizeFeature::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_size_feature(
-        &mut self,
-        node: SizeFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeature {
-        <SizeFeature as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
+        <SizeFeature as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
-             [`SizeFeatureBoolean::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SizeFeatureBoolean::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_size_feature_boolean(
-        &mut self,
-        node: SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureBoolean {
-        <SizeFeatureBoolean as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
+        <SizeFeatureBoolean as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
-             [`SizeFeatureName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SizeFeatureName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_size_feature_name(
-        &mut self,
-        node: SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureName {
-        <SizeFeatureName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
+        <SizeFeatureName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
-             [`SizeFeaturePlain::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SizeFeaturePlain::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_size_feature_plain(
-        &mut self,
-        node: SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeaturePlain {
-        <SizeFeaturePlain as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
+        <SizeFeaturePlain as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
-             [`SizeFeatureRange::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SizeFeatureRange::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_size_feature_range(
-        &mut self,
-        node: SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureRange {
-        <SizeFeatureRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
+        <SizeFeatureRange as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeComparison::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`SizeFeatureRangeComparison::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_size_feature_range_comparison(
         &mut self,
         node: SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeComparison {
-        <SizeFeatureRangeComparison as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <SizeFeatureRangeComparison as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeInterval::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`SizeFeatureRangeInterval::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_size_feature_range_interval(
         &mut self,
         node: SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeInterval {
-        <SizeFeatureRangeInterval as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <SizeFeatureRangeInterval as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
-             [`SizeFeatureValue::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SizeFeatureValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_size_feature_value(
-        &mut self,
-        node: SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureValue {
-        <SizeFeatureValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
+        <SizeFeatureValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`swc_common :: Span::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
-        <swc_common::Span as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+        <swc_common::Span as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Str::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
-        <Str as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_str(&mut self, node: Str) -> Str {
+        <Str as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
-             [`StyleBlock::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`StyleBlock::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
-        <StyleBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
+        <StyleBlock as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
-             [`Stylesheet::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Stylesheet::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
-        <Stylesheet as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
+        <Stylesheet as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
-             [`SubclassSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SubclassSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_subclass_selector(
-        &mut self,
-        node: SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> SubclassSelector {
-        <SubclassSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
+        <SubclassSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
-             [`Vec < SubclassSelector >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < SubclassSelector >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_subclass_selectors(
-        &mut self,
-        node: Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SubclassSelector> {
-        <Vec<SubclassSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
+        <Vec<SubclassSelector> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
-             [`SupportsAnd::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SupportsAnd::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_supports_and(
-        &mut self,
-        node: SupportsAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsAnd {
-        <SupportsAnd as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
+        <SupportsAnd as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
-             [`SupportsCondition::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SupportsCondition::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_supports_condition(
-        &mut self,
-        node: SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsCondition {
-        <SupportsCondition as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
+        <SupportsCondition as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
-             [`SupportsConditionType::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SupportsConditionType::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_supports_condition_type(
         &mut self,
         node: SupportsConditionType,
-        __ast_path: &mut AstKindPath,
     ) -> SupportsConditionType {
-        <SupportsConditionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <SupportsConditionType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
-             calls [`Vec < SupportsConditionType >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < SupportsConditionType >::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
     fn fold_supports_condition_types(
         &mut self,
         node: Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<SupportsConditionType> {
-        <Vec<SupportsConditionType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<SupportsConditionType> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
-             [`SupportsFeature::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn fold_supports_feature(
-        &mut self,
-        node: SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsFeature {
-        <SupportsFeature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
-             [`SupportsInParens::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SupportsFeature::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_supports_in_parens(
-        &mut self,
-        node: SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsInParens {
-        <SupportsInParens as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
+        <SupportsFeature as FoldWith<Self>>::fold_children_with(node, self)
+    }
+    #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
+             [`SupportsInParens::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
+    #[inline]
+    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
+        <SupportsInParens as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
-             [`SupportsNot::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SupportsNot::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_supports_not(
-        &mut self,
-        node: SupportsNot,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsNot {
-        <SupportsNot as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
+        <SupportsNot as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
-             [`SupportsOr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SupportsOr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
-        <SupportsOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
+        <SupportsOr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
-             [`TagNameSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TagNameSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_tag_name_selector(
-        &mut self,
-        node: TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TagNameSelector {
-        <TagNameSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
+        <TagNameSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
-             [`Time::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Time::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
-        <Time as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_time(&mut self, node: Time) -> Time {
+        <Time as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
-             [`TimePercentage::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TimePercentage::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_time_percentage(
-        &mut self,
-        node: TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> TimePercentage {
-        <TimePercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
+        <TimePercentage as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Token::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
-        <Token as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_token(&mut self, node: Token) -> Token {
+        <Token as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TokenAndSpan::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_token_and_span(
-        &mut self,
-        node: TokenAndSpan,
-        __ast_path: &mut AstKindPath,
-    ) -> TokenAndSpan {
-        <TokenAndSpan as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
+        <TokenAndSpan as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
-             [`TypeSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TypeSelector::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_type_selector(
-        &mut self,
-        node: TypeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TypeSelector {
-        <TypeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
+        <TypeSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
-             [`UnicodeRange::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UnicodeRange::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_unicode_range(
-        &mut self,
-        node: UnicodeRange,
-        __ast_path: &mut AstKindPath,
-    ) -> UnicodeRange {
-        <UnicodeRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
+        <UnicodeRange as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
-             [`UniversalSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`UniversalSelector::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_universal_selector(
-        &mut self,
-        node: UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> UniversalSelector {
-        <UniversalSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
+        <UniversalSelector as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
-             [`UnknownDimension::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`UnknownDimension::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_unknown_dimension(
-        &mut self,
-        node: UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) -> UnknownDimension {
-        <UnknownDimension as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
+        <UnknownDimension as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
-             [`Url::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Url::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
-        <Url as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_url(&mut self, node: Url) -> Url {
+        <Url as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
-             [`UrlKeyValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UrlKeyValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_url_key_value(
-        &mut self,
-        node: UrlKeyValue,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlKeyValue {
-        <UrlKeyValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
+        <UrlKeyValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
-             [`UrlModifier::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UrlModifier::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_url_modifier(
-        &mut self,
-        node: UrlModifier,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlModifier {
-        <UrlModifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
+        <UrlModifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
-             UrlModifier >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             UrlModifier >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_url_modifiers(
-        &mut self,
-        node: Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<UrlModifier> {
-        <Vec<UrlModifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
+        <Vec<UrlModifier> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
-             [`UrlValue::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`UrlValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
-        <UrlValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
+        <UrlValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
-             [`UrlValueRaw::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UrlValueRaw::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_url_value_raw(
-        &mut self,
-        node: UrlValueRaw,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlValueRaw {
-        <UrlValueRaw as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
+        <UrlValueRaw as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
-             [`WqName::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`WqName::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
-        <WqName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_wq_name(&mut self, node: WqName) -> WqName {
+        <WqName as FoldWith<Self>>::fold_children_with(node, self)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> FoldAstPath for &mut V
+impl<V> Fold for &mut V
 where
-    V: ?Sized + FoldAstPath,
+    V: ?Sized + Fold,
 {
     #[inline]
-    fn fold_absolute_color_base(
-        &mut self,
-        node: AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) -> AbsoluteColorBase {
-        <V as FoldAstPath>::fold_absolute_color_base(&mut **self, node, __ast_path)
+    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
+        <V as Fold>::fold_absolute_color_base(&mut **self, node)
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
-        <V as FoldAstPath>::fold_alpha_value(&mut **self, node, __ast_path)
+    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
+        <V as Fold>::fold_alpha_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
-        <V as FoldAstPath>::fold_an_plus_b(&mut **self, node, __ast_path)
+    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
+        <V as Fold>::fold_an_plus_b(&mut **self, node)
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(
-        &mut self,
-        node: AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) -> AnPlusBNotation {
-        <V as FoldAstPath>::fold_an_plus_b_notation(&mut **self, node, __ast_path)
+    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
+        <V as Fold>::fold_an_plus_b_notation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
-        <V as FoldAstPath>::fold_angle(&mut **self, node, __ast_path)
+    fn fold_angle(&mut self, node: Angle) -> Angle {
+        <V as Fold>::fold_angle(&mut **self, node)
     }
 
     #[inline]
-    fn fold_angle_percentage(
-        &mut self,
-        node: AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> AnglePercentage {
-        <V as FoldAstPath>::fold_angle_percentage(&mut **self, node, __ast_path)
+    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
+        <V as Fold>::fold_angle_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_any_namespace(
-        &mut self,
-        node: AnyNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> AnyNamespace {
-        <V as FoldAstPath>::fold_any_namespace(&mut **self, node, __ast_path)
+    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
+        <V as Fold>::fold_any_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
-        <V as FoldAstPath>::fold_at_rule(&mut **self, node, __ast_path)
+    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
+        <V as Fold>::fold_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
-        <V as FoldAstPath>::fold_at_rule_name(&mut **self, node, __ast_path)
+    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
+        <V as Fold>::fold_at_rule_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_at_rule_prelude(
-        &mut self,
-        node: AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> AtRulePrelude {
-        <V as FoldAstPath>::fold_at_rule_prelude(&mut **self, node, __ast_path)
+    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
+        <V as Fold>::fold_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
-        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+        <V as Fold>::fold_atom(&mut **self, node)
     }
 
     #[inline]
-    fn fold_attribute_selector(
-        &mut self,
-        node: AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> AttributeSelector {
-        <V as FoldAstPath>::fold_attribute_selector(&mut **self, node, __ast_path)
+    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
+        <V as Fold>::fold_attribute_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_matcher(
         &mut self,
         node: AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcher {
-        <V as FoldAstPath>::fold_attribute_selector_matcher(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_matcher_value(
         &mut self,
         node: AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcherValue {
-        <V as FoldAstPath>::fold_attribute_selector_matcher_value(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_matcher_value(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_modifier(
         &mut self,
         node: AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorModifier {
-        <V as FoldAstPath>::fold_attribute_selector_modifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_value(
         &mut self,
         node: AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorValue {
-        <V as FoldAstPath>::fold_attribute_selector_value(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
-        <V as FoldAstPath>::fold_bin_op(&mut **self, node, __ast_path)
+    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
+        <V as Fold>::fold_bin_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_operator(
-        &mut self,
-        node: CalcOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperator {
-        <V as FoldAstPath>::fold_calc_operator(&mut **self, node, __ast_path)
+    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
+        <V as Fold>::fold_calc_operator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_operator_type(
-        &mut self,
-        node: CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperatorType {
-        <V as FoldAstPath>::fold_calc_operator_type(&mut **self, node, __ast_path)
+    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
+        <V as Fold>::fold_calc_operator_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_product(
-        &mut self,
-        node: CalcProduct,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcProduct {
-        <V as FoldAstPath>::fold_calc_product(&mut **self, node, __ast_path)
+    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
+        <V as Fold>::fold_calc_product(&mut **self, node)
     }
 
     #[inline]
     fn fold_calc_product_or_operator(
         &mut self,
         node: CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
     ) -> CalcProductOrOperator {
-        <V as FoldAstPath>::fold_calc_product_or_operator(&mut **self, node, __ast_path)
+        <V as Fold>::fold_calc_product_or_operator(&mut **self, node)
     }
 
     #[inline]
     fn fold_calc_product_or_operators(
         &mut self,
         node: Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcProductOrOperator> {
-        <V as FoldAstPath>::fold_calc_product_or_operators(&mut **self, node, __ast_path)
+        <V as Fold>::fold_calc_product_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
-        <V as FoldAstPath>::fold_calc_sum(&mut **self, node, __ast_path)
+    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
+        <V as Fold>::fold_calc_sum(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
-        <V as FoldAstPath>::fold_calc_value(&mut **self, node, __ast_path)
+    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
+        <V as Fold>::fold_calc_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(
-        &mut self,
-        node: CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcValueOrOperator {
-        <V as FoldAstPath>::fold_calc_value_or_operator(&mut **self, node, __ast_path)
+    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
+        <V as Fold>::fold_calc_value_or_operator(&mut **self, node)
     }
 
     #[inline]
     fn fold_calc_value_or_operators(
         &mut self,
         node: Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcValueOrOperator> {
-        <V as FoldAstPath>::fold_calc_value_or_operators(&mut **self, node, __ast_path)
+        <V as Fold>::fold_calc_value_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_selector(
-        &mut self,
-        node: ClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassSelector {
-        <V as FoldAstPath>::fold_class_selector(&mut **self, node, __ast_path)
+    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
+        <V as Fold>::fold_class_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_cmyk_component(
-        &mut self,
-        node: CmykComponent,
-        __ast_path: &mut AstKindPath,
-    ) -> CmykComponent {
-        <V as FoldAstPath>::fold_cmyk_component(&mut **self, node, __ast_path)
+    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
+        <V as Fold>::fold_cmyk_component(&mut **self, node)
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
-        <V as FoldAstPath>::fold_color(&mut **self, node, __ast_path)
+    fn fold_color(&mut self, node: Color) -> Color {
+        <V as Fold>::fold_color(&mut **self, node)
     }
 
     #[inline]
-    fn fold_color_profile_name(
-        &mut self,
-        node: ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) -> ColorProfileName {
-        <V as FoldAstPath>::fold_color_profile_name(&mut **self, node, __ast_path)
+    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
+        <V as Fold>::fold_color_profile_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
-        <V as FoldAstPath>::fold_combinator(&mut **self, node, __ast_path)
+    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
+        <V as Fold>::fold_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_combinator_value(
-        &mut self,
-        node: CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) -> CombinatorValue {
-        <V as FoldAstPath>::fold_combinator_value(&mut **self, node, __ast_path)
+    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
+        <V as Fold>::fold_combinator_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_complex_selector(
-        &mut self,
-        node: ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ComplexSelector {
-        <V as FoldAstPath>::fold_complex_selector(&mut **self, node, __ast_path)
+    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
+        <V as Fold>::fold_complex_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_complex_selector_children(
         &mut self,
         node: ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> ComplexSelectorChildren {
-        <V as FoldAstPath>::fold_complex_selector_children(&mut **self, node, __ast_path)
+        <V as Fold>::fold_complex_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn fold_complex_selector_childrens(
         &mut self,
         node: Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ComplexSelectorChildren> {
-        <V as FoldAstPath>::fold_complex_selector_childrens(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn fold_complex_selectors(
-        &mut self,
-        node: Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComplexSelector> {
-        <V as FoldAstPath>::fold_complex_selectors(&mut **self, node, __ast_path)
+        <V as Fold>::fold_complex_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_component_value(
-        &mut self,
-        node: ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) -> ComponentValue {
-        <V as FoldAstPath>::fold_component_value(&mut **self, node, __ast_path)
+    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
+        <V as Fold>::fold_complex_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_component_values(
-        &mut self,
-        node: Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComponentValue> {
-        <V as FoldAstPath>::fold_component_values(&mut **self, node, __ast_path)
+    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
+        <V as Fold>::fold_component_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_compound_selector(
-        &mut self,
-        node: CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelector {
-        <V as FoldAstPath>::fold_compound_selector(&mut **self, node, __ast_path)
+    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
+        <V as Fold>::fold_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn fold_compound_selector_list(
-        &mut self,
-        node: CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelectorList {
-        <V as FoldAstPath>::fold_compound_selector_list(&mut **self, node, __ast_path)
+    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
+        <V as Fold>::fold_compound_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_compound_selectors(
-        &mut self,
-        node: Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CompoundSelector> {
-        <V as FoldAstPath>::fold_compound_selectors(&mut **self, node, __ast_path)
+    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
+        <V as Fold>::fold_compound_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_condition(
-        &mut self,
-        node: ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerCondition {
-        <V as FoldAstPath>::fold_container_condition(&mut **self, node, __ast_path)
+    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
+        <V as Fold>::fold_compound_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_name(
-        &mut self,
-        node: ContainerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerName {
-        <V as FoldAstPath>::fold_container_name(&mut **self, node, __ast_path)
+    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
+        <V as Fold>::fold_container_condition(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query(
-        &mut self,
-        node: ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQuery {
-        <V as FoldAstPath>::fold_container_query(&mut **self, node, __ast_path)
+    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
+        <V as Fold>::fold_container_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_and(
-        &mut self,
-        node: ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryAnd {
-        <V as FoldAstPath>::fold_container_query_and(&mut **self, node, __ast_path)
+    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
+        <V as Fold>::fold_container_query(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_not(
-        &mut self,
-        node: ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryNot {
-        <V as FoldAstPath>::fold_container_query_not(&mut **self, node, __ast_path)
+    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
+        <V as Fold>::fold_container_query_and(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_or(
-        &mut self,
-        node: ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryOr {
-        <V as FoldAstPath>::fold_container_query_or(&mut **self, node, __ast_path)
+    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
+        <V as Fold>::fold_container_query_not(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_type(
-        &mut self,
-        node: ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryType {
-        <V as FoldAstPath>::fold_container_query_type(&mut **self, node, __ast_path)
+    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
+        <V as Fold>::fold_container_query_or(&mut **self, node)
+    }
+
+    #[inline]
+    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
+        <V as Fold>::fold_container_query_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_container_query_types(
         &mut self,
         node: Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ContainerQueryType> {
-        <V as FoldAstPath>::fold_container_query_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_container_query_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_highlight_name(
-        &mut self,
-        node: CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomHighlightName {
-        <V as FoldAstPath>::fold_custom_highlight_name(&mut **self, node, __ast_path)
+    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
+        <V as Fold>::fold_custom_highlight_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_ident(
-        &mut self,
-        node: CustomIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomIdent {
-        <V as FoldAstPath>::fold_custom_ident(&mut **self, node, __ast_path)
+    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
+        <V as Fold>::fold_custom_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_idents(
-        &mut self,
-        node: Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CustomIdent> {
-        <V as FoldAstPath>::fold_custom_idents(&mut **self, node, __ast_path)
+    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
+        <V as Fold>::fold_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_media_query(
-        &mut self,
-        node: CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomMediaQuery {
-        <V as FoldAstPath>::fold_custom_media_query(&mut **self, node, __ast_path)
+    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
+        <V as Fold>::fold_custom_media_query(&mut **self, node)
     }
 
     #[inline]
     fn fold_custom_media_query_media_type(
         &mut self,
         node: CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
     ) -> CustomMediaQueryMediaType {
-        <V as FoldAstPath>::fold_custom_media_query_media_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_custom_media_query_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_property_name(
-        &mut self,
-        node: CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomPropertyName {
-        <V as FoldAstPath>::fold_custom_property_name(&mut **self, node, __ast_path)
+    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
+        <V as Fold>::fold_custom_property_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_dashed_ident(
-        &mut self,
-        node: DashedIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> DashedIdent {
-        <V as FoldAstPath>::fold_dashed_ident(&mut **self, node, __ast_path)
+    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
+        <V as Fold>::fold_dashed_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
-        <V as FoldAstPath>::fold_declaration(&mut **self, node, __ast_path)
+    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
+        <V as Fold>::fold_declaration(&mut **self, node)
     }
 
     #[inline]
-    fn fold_declaration_name(
-        &mut self,
-        node: DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationName {
-        <V as FoldAstPath>::fold_declaration_name(&mut **self, node, __ast_path)
+    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
+        <V as Fold>::fold_declaration_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(
-        &mut self,
-        node: DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationOrAtRule {
-        <V as FoldAstPath>::fold_declaration_or_at_rule(&mut **self, node, __ast_path)
+    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
+        <V as Fold>::fold_declaration_or_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
-        <V as FoldAstPath>::fold_delimiter(&mut **self, node, __ast_path)
+    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
+        <V as Fold>::fold_delimiter(&mut **self, node)
     }
 
     #[inline]
-    fn fold_delimiter_value(
-        &mut self,
-        node: DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) -> DelimiterValue {
-        <V as FoldAstPath>::fold_delimiter_value(&mut **self, node, __ast_path)
+    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
+        <V as Fold>::fold_delimiter_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
-        <V as FoldAstPath>::fold_dimension(&mut **self, node, __ast_path)
+    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
+        <V as Fold>::fold_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn fold_dimension_token(
-        &mut self,
-        node: DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) -> DimensionToken {
-        <V as FoldAstPath>::fold_dimension_token(&mut **self, node, __ast_path)
+    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
+        <V as Fold>::fold_dimension_token(&mut **self, node)
     }
 
     #[inline]
-    fn fold_document_prelude(
-        &mut self,
-        node: DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> DocumentPrelude {
-        <V as FoldAstPath>::fold_document_prelude(&mut **self, node, __ast_path)
+    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
+        <V as Fold>::fold_document_prelude(&mut **self, node)
     }
 
     #[inline]
     fn fold_document_prelude_matching_function(
         &mut self,
         node: DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) -> DocumentPreludeMatchingFunction {
-        <V as FoldAstPath>::fold_document_prelude_matching_function(&mut **self, node, __ast_path)
+        <V as Fold>::fold_document_prelude_matching_function(&mut **self, node)
     }
 
     #[inline]
     fn fold_document_prelude_matching_functions(
         &mut self,
         node: Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<DocumentPreludeMatchingFunction> {
-        <V as FoldAstPath>::fold_document_prelude_matching_functions(&mut **self, node, __ast_path)
+        <V as Fold>::fold_document_prelude_matching_functions(&mut **self, node)
     }
 
     #[inline]
-    fn fold_extension_name(
-        &mut self,
-        node: ExtensionName,
-        __ast_path: &mut AstKindPath,
-    ) -> ExtensionName {
-        <V as FoldAstPath>::fold_extension_name(&mut **self, node, __ast_path)
+    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
+        <V as Fold>::fold_extension_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
-        <V as FoldAstPath>::fold_family_name(&mut **self, node, __ast_path)
+    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
+        <V as Fold>::fold_family_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_family_names(
-        &mut self,
-        node: Vec<FamilyName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<FamilyName> {
-        <V as FoldAstPath>::fold_family_names(&mut **self, node, __ast_path)
+    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
+        <V as Fold>::fold_family_names(&mut **self, node)
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
-        <V as FoldAstPath>::fold_flex(&mut **self, node, __ast_path)
+    fn fold_flex(&mut self, node: Flex) -> Flex {
+        <V as Fold>::fold_flex(&mut **self, node)
     }
 
     #[inline]
     fn fold_font_feature_values_prelude(
         &mut self,
         node: FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
     ) -> FontFeatureValuesPrelude {
-        <V as FoldAstPath>::fold_font_feature_values_prelude(&mut **self, node, __ast_path)
+        <V as Fold>::fold_font_feature_values_prelude(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_complex_selector(
         &mut self,
         node: ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingComplexSelector {
-        <V as FoldAstPath>::fold_forgiving_complex_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_complex_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_complex_selectors(
         &mut self,
         node: Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingComplexSelector> {
-        <V as FoldAstPath>::fold_forgiving_complex_selectors(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_complex_selectors(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_relative_selector(
         &mut self,
         node: ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelector {
-        <V as FoldAstPath>::fold_forgiving_relative_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_relative_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_relative_selector_list(
         &mut self,
         node: ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelectorList {
-        <V as FoldAstPath>::fold_forgiving_relative_selector_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_relative_selectors(
         &mut self,
         node: Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingRelativeSelector> {
-        <V as FoldAstPath>::fold_forgiving_relative_selectors(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_relative_selectors(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_selector_list(
         &mut self,
         node: ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingSelectorList {
-        <V as FoldAstPath>::fold_forgiving_selector_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
-        <V as FoldAstPath>::fold_frequency(&mut **self, node, __ast_path)
+    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
+        <V as Fold>::fold_frequency(&mut **self, node)
     }
 
     #[inline]
-    fn fold_frequency_percentage(
-        &mut self,
-        node: FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> FrequencyPercentage {
-        <V as FoldAstPath>::fold_frequency_percentage(&mut **self, node, __ast_path)
+    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
+        <V as Fold>::fold_frequency_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
-        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
+    fn fold_function(&mut self, node: Function) -> Function {
+        <V as Fold>::fold_function(&mut **self, node)
     }
 
     #[inline]
-    fn fold_function_name(
-        &mut self,
-        node: FunctionName,
-        __ast_path: &mut AstKindPath,
-    ) -> FunctionName {
-        <V as FoldAstPath>::fold_function_name(&mut **self, node, __ast_path)
+    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
+        <V as Fold>::fold_function_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_general_enclosed(
-        &mut self,
-        node: GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) -> GeneralEnclosed {
-        <V as FoldAstPath>::fold_general_enclosed(&mut **self, node, __ast_path)
+    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
+        <V as Fold>::fold_general_enclosed(&mut **self, node)
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
-        <V as FoldAstPath>::fold_hex_color(&mut **self, node, __ast_path)
+    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
+        <V as Fold>::fold_hex_color(&mut **self, node)
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
-        <V as FoldAstPath>::fold_hue(&mut **self, node, __ast_path)
+    fn fold_hue(&mut self, node: Hue) -> Hue {
+        <V as Fold>::fold_hue(&mut **self, node)
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
-        <V as FoldAstPath>::fold_id_selector(&mut **self, node, __ast_path)
+    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
+        <V as Fold>::fold_id_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
-        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
+    fn fold_ident(&mut self, node: Ident) -> Ident {
+        <V as Fold>::fold_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
-        <V as FoldAstPath>::fold_idents(&mut **self, node, __ast_path)
+    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
+        <V as Fold>::fold_idents(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_conditions(
-        &mut self,
-        node: ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportConditions {
-        <V as FoldAstPath>::fold_import_conditions(&mut **self, node, __ast_path)
+    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
+        <V as Fold>::fold_import_conditions(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
-        <V as FoldAstPath>::fold_import_href(&mut **self, node, __ast_path)
+    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
+        <V as Fold>::fold_import_href(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_layer_name(
-        &mut self,
-        node: ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportLayerName {
-        <V as FoldAstPath>::fold_import_layer_name(&mut **self, node, __ast_path)
+    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
+        <V as Fold>::fold_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_prelude(
-        &mut self,
-        node: ImportPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPrelude {
-        <V as FoldAstPath>::fold_import_prelude(&mut **self, node, __ast_path)
+    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
+        <V as Fold>::fold_import_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_important_flag(
-        &mut self,
-        node: ImportantFlag,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportantFlag {
-        <V as FoldAstPath>::fold_important_flag(&mut **self, node, __ast_path)
+    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
+        <V as Fold>::fold_important_flag(&mut **self, node)
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
-        <V as FoldAstPath>::fold_integer(&mut **self, node, __ast_path)
+    fn fold_integer(&mut self, node: Integer) -> Integer {
+        <V as Fold>::fold_integer(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframe_block(
-        &mut self,
-        node: KeyframeBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeBlock {
-        <V as FoldAstPath>::fold_keyframe_block(&mut **self, node, __ast_path)
+    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
+        <V as Fold>::fold_keyframe_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframe_selector(
-        &mut self,
-        node: KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeSelector {
-        <V as FoldAstPath>::fold_keyframe_selector(&mut **self, node, __ast_path)
+    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
+        <V as Fold>::fold_keyframe_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframe_selectors(
-        &mut self,
-        node: Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<KeyframeSelector> {
-        <V as FoldAstPath>::fold_keyframe_selectors(&mut **self, node, __ast_path)
+    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
+        <V as Fold>::fold_keyframe_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframes_name(
-        &mut self,
-        node: KeyframesName,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframesName {
-        <V as FoldAstPath>::fold_keyframes_name(&mut **self, node, __ast_path)
+    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
+        <V as Fold>::fold_keyframes_name(&mut **self, node)
     }
 
     #[inline]
     fn fold_keyframes_pseudo_function(
         &mut self,
         node: KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoFunction {
-        <V as FoldAstPath>::fold_keyframes_pseudo_function(&mut **self, node, __ast_path)
+        <V as Fold>::fold_keyframes_pseudo_function(&mut **self, node)
     }
 
     #[inline]
     fn fold_keyframes_pseudo_prefix(
         &mut self,
         node: KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoPrefix {
-        <V as FoldAstPath>::fold_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
+        <V as Fold>::fold_keyframes_pseudo_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
-        <V as FoldAstPath>::fold_layer_name(&mut **self, node, __ast_path)
+    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
+        <V as Fold>::fold_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_name_list(
-        &mut self,
-        node: LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerNameList {
-        <V as FoldAstPath>::fold_layer_name_list(&mut **self, node, __ast_path)
+    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
+        <V as Fold>::fold_layer_name_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_names(
-        &mut self,
-        node: Vec<LayerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<LayerName> {
-        <V as FoldAstPath>::fold_layer_names(&mut **self, node, __ast_path)
+    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
+        <V as Fold>::fold_layer_names(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_prelude(
-        &mut self,
-        node: LayerPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerPrelude {
-        <V as FoldAstPath>::fold_layer_prelude(&mut **self, node, __ast_path)
+    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
+        <V as Fold>::fold_layer_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
-        <V as FoldAstPath>::fold_length(&mut **self, node, __ast_path)
+    fn fold_length(&mut self, node: Length) -> Length {
+        <V as Fold>::fold_length(&mut **self, node)
     }
 
     #[inline]
-    fn fold_length_percentage(
-        &mut self,
-        node: LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> LengthPercentage {
-        <V as FoldAstPath>::fold_length_percentage(&mut **self, node, __ast_path)
+    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
+        <V as Fold>::fold_length_percentage(&mut **self, node)
     }
 
     #[inline]
     fn fold_list_of_component_values(
         &mut self,
         node: ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
     ) -> ListOfComponentValues {
-        <V as FoldAstPath>::fold_list_of_component_values(&mut **self, node, __ast_path)
+        <V as Fold>::fold_list_of_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
-        <V as FoldAstPath>::fold_media_and(&mut **self, node, __ast_path)
+    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
+        <V as Fold>::fold_media_and(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_condition(
-        &mut self,
-        node: MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaCondition {
-        <V as FoldAstPath>::fold_media_condition(&mut **self, node, __ast_path)
+    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
+        <V as Fold>::fold_media_condition(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_all_type(
         &mut self,
         node: MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionAllType {
-        <V as FoldAstPath>::fold_media_condition_all_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_all_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_all_types(
         &mut self,
         node: Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionAllType> {
-        <V as FoldAstPath>::fold_media_condition_all_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_all_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_condition_type(
-        &mut self,
-        node: MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaConditionType {
-        <V as FoldAstPath>::fold_media_condition_type(&mut **self, node, __ast_path)
+    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
+        <V as Fold>::fold_media_condition_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_without_or(
         &mut self,
         node: MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOr {
-        <V as FoldAstPath>::fold_media_condition_without_or(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_without_or(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_without_or_type(
         &mut self,
         node: MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOrType {
-        <V as FoldAstPath>::fold_media_condition_without_or_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_without_or_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_without_or_types(
         &mut self,
         node: Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionWithoutOrType> {
-        <V as FoldAstPath>::fold_media_condition_without_or_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_without_or_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature(
-        &mut self,
-        node: MediaFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeature {
-        <V as FoldAstPath>::fold_media_feature(&mut **self, node, __ast_path)
+    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
+        <V as Fold>::fold_media_feature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_boolean(
-        &mut self,
-        node: MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureBoolean {
-        <V as FoldAstPath>::fold_media_feature_boolean(&mut **self, node, __ast_path)
+    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
+        <V as Fold>::fold_media_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_name(
-        &mut self,
-        node: MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureName {
-        <V as FoldAstPath>::fold_media_feature_name(&mut **self, node, __ast_path)
+    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
+        <V as Fold>::fold_media_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_plain(
-        &mut self,
-        node: MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeaturePlain {
-        <V as FoldAstPath>::fold_media_feature_plain(&mut **self, node, __ast_path)
+    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
+        <V as Fold>::fold_media_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_range(
-        &mut self,
-        node: MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureRange {
-        <V as FoldAstPath>::fold_media_feature_range(&mut **self, node, __ast_path)
+    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
+        <V as Fold>::fold_media_feature_range(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_feature_range_comparison(
         &mut self,
         node: MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeComparison {
-        <V as FoldAstPath>::fold_media_feature_range_comparison(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_feature_range_interval(
         &mut self,
         node: MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeInterval {
-        <V as FoldAstPath>::fold_media_feature_range_interval(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_value(
-        &mut self,
-        node: MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureValue {
-        <V as FoldAstPath>::fold_media_feature_value(&mut **self, node, __ast_path)
+    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
+        <V as Fold>::fold_media_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_in_parens(
-        &mut self,
-        node: MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaInParens {
-        <V as FoldAstPath>::fold_media_in_parens(&mut **self, node, __ast_path)
+    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
+        <V as Fold>::fold_media_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
-        <V as FoldAstPath>::fold_media_not(&mut **self, node, __ast_path)
+    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
+        <V as Fold>::fold_media_not(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
-        <V as FoldAstPath>::fold_media_or(&mut **self, node, __ast_path)
+    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
+        <V as Fold>::fold_media_or(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
-        <V as FoldAstPath>::fold_media_query(&mut **self, node, __ast_path)
+    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
+        <V as Fold>::fold_media_query(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_query_list(
-        &mut self,
-        node: MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaQueryList {
-        <V as FoldAstPath>::fold_media_query_list(&mut **self, node, __ast_path)
+    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
+        <V as Fold>::fold_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_querys(
-        &mut self,
-        node: Vec<MediaQuery>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<MediaQuery> {
-        <V as FoldAstPath>::fold_media_querys(&mut **self, node, __ast_path)
+    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
+        <V as Fold>::fold_media_querys(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
-        <V as FoldAstPath>::fold_media_type(&mut **self, node, __ast_path)
+    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
+        <V as Fold>::fold_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_named_namespace(
-        &mut self,
-        node: NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedNamespace {
-        <V as FoldAstPath>::fold_named_namespace(&mut **self, node, __ast_path)
+    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
+        <V as Fold>::fold_named_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
-        <V as FoldAstPath>::fold_namespace(&mut **self, node, __ast_path)
+    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
+        <V as Fold>::fold_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace_prefix(
-        &mut self,
-        node: NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrefix {
-        <V as FoldAstPath>::fold_namespace_prefix(&mut **self, node, __ast_path)
+    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
+        <V as Fold>::fold_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace_prelude(
-        &mut self,
-        node: NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrelude {
-        <V as FoldAstPath>::fold_namespace_prelude(&mut **self, node, __ast_path)
+    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
+        <V as Fold>::fold_namespace_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(
-        &mut self,
-        node: NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePreludeUri {
-        <V as FoldAstPath>::fold_namespace_prelude_uri(&mut **self, node, __ast_path)
+    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
+        <V as Fold>::fold_namespace_prelude_uri(&mut **self, node)
     }
 
     #[inline]
-    fn fold_nesting_selector(
-        &mut self,
-        node: NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> NestingSelector {
-        <V as FoldAstPath>::fold_nesting_selector(&mut **self, node, __ast_path)
+    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
+        <V as Fold>::fold_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
-        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
+    fn fold_number(&mut self, node: Number) -> Number {
+        <V as Fold>::fold_number(&mut **self, node)
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
-        <V as FoldAstPath>::fold_number_type(&mut **self, node, __ast_path)
+    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
+        <V as Fold>::fold_number_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_at_rule_prelude(
         &mut self,
         node: Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<AtRulePrelude>> {
-        <V as FoldAstPath>::fold_opt_at_rule_prelude(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
-        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+        <V as Fold>::fold_opt_atom(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_attribute_selector_matcher(
         &mut self,
         node: Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorMatcher> {
-        <V as FoldAstPath>::fold_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_attribute_selector_modifier(
         &mut self,
         node: Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorModifier> {
-        <V as FoldAstPath>::fold_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_attribute_selector_value(
         &mut self,
         node: Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorValue> {
-        <V as FoldAstPath>::fold_opt_attribute_selector_value(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_combinator(
-        &mut self,
-        node: Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Combinator> {
-        <V as FoldAstPath>::fold_opt_combinator(&mut **self, node, __ast_path)
+    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
+        <V as Fold>::fold_opt_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_container_name(
-        &mut self,
-        node: Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ContainerName> {
-        <V as FoldAstPath>::fold_opt_container_name(&mut **self, node, __ast_path)
+    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
+        <V as Fold>::fold_opt_container_name(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_forgiving_selector_list(
         &mut self,
         node: Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ForgivingSelectorList> {
-        <V as FoldAstPath>::fold_opt_forgiving_selector_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_function(
-        &mut self,
-        node: Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Function>> {
-        <V as FoldAstPath>::fold_opt_function(&mut **self, node, __ast_path)
+    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
+        <V as Fold>::fold_opt_function(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
-        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+        <V as Fold>::fold_opt_ident(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_import_conditions(
         &mut self,
         node: Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportConditions>> {
-        <V as FoldAstPath>::fold_opt_import_conditions(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_import_conditions(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_import_layer_name(
         &mut self,
         node: Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportLayerName>> {
-        <V as FoldAstPath>::fold_opt_import_layer_name(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_important_flag(
-        &mut self,
-        node: Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ImportantFlag> {
-        <V as FoldAstPath>::fold_opt_important_flag(&mut **self, node, __ast_path)
+    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
+        <V as Fold>::fold_opt_important_flag(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_media_condition_type(
         &mut self,
         node: Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaConditionType>> {
-        <V as FoldAstPath>::fold_opt_media_condition_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_media_condition_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_media_query_list(
         &mut self,
         node: Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaQueryList>> {
-        <V as FoldAstPath>::fold_opt_media_query_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_media_type(
-        &mut self,
-        node: Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<MediaType> {
-        <V as FoldAstPath>::fold_opt_media_type(&mut **self, node, __ast_path)
+    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
+        <V as Fold>::fold_opt_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_namespace(
-        &mut self,
-        node: Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Namespace> {
-        <V as FoldAstPath>::fold_opt_namespace(&mut **self, node, __ast_path)
+    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
+        <V as Fold>::fold_opt_namespace(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_namespace_prefix(
         &mut self,
         node: Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NamespacePrefix> {
-        <V as FoldAstPath>::fold_opt_namespace_prefix(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_nesting_selector(
         &mut self,
         node: Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NestingSelector> {
-        <V as FoldAstPath>::fold_opt_nesting_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_number(
-        &mut self,
-        node: Option<Number>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Number> {
-        <V as FoldAstPath>::fold_opt_number(&mut **self, node, __ast_path)
+    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
+        <V as Fold>::fold_opt_number(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_page_selector_pseudos(
         &mut self,
         node: Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PageSelectorPseudo>> {
-        <V as FoldAstPath>::fold_opt_page_selector_pseudos(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_page_selector_type(
         &mut self,
         node: Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<PageSelectorType> {
-        <V as FoldAstPath>::fold_opt_page_selector_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_page_selector_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoClassSelectorChildren>> {
-        <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoElementSelectorChildren>> {
-        <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as Fold>::fold_opt_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_simple_block(
-        &mut self,
-        node: Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<SimpleBlock> {
-        <V as FoldAstPath>::fold_opt_simple_block(&mut **self, node, __ast_path)
+    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
+        <V as Fold>::fold_opt_simple_block(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_type_selector(
         &mut self,
         node: Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TypeSelector>> {
-        <V as FoldAstPath>::fold_opt_type_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_type_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_url_modifiers(
         &mut self,
         node: Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<UrlModifier>> {
-        <V as FoldAstPath>::fold_opt_url_modifiers(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_url_value(
-        &mut self,
-        node: Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<UrlValue>> {
-        <V as FoldAstPath>::fold_opt_url_value(&mut **self, node, __ast_path)
+    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
+        <V as Fold>::fold_opt_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector(
-        &mut self,
-        node: PageSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelector {
-        <V as FoldAstPath>::fold_page_selector(&mut **self, node, __ast_path)
+    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
+        <V as Fold>::fold_page_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector_list(
-        &mut self,
-        node: PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorList {
-        <V as FoldAstPath>::fold_page_selector_list(&mut **self, node, __ast_path)
+    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
+        <V as Fold>::fold_page_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(
-        &mut self,
-        node: PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorPseudo {
-        <V as FoldAstPath>::fold_page_selector_pseudo(&mut **self, node, __ast_path)
+    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
+        <V as Fold>::fold_page_selector_pseudo(&mut **self, node)
     }
 
     #[inline]
     fn fold_page_selector_pseudos(
         &mut self,
         node: Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PageSelectorPseudo> {
-        <V as FoldAstPath>::fold_page_selector_pseudos(&mut **self, node, __ast_path)
+        <V as Fold>::fold_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector_type(
-        &mut self,
-        node: PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorType {
-        <V as FoldAstPath>::fold_page_selector_type(&mut **self, node, __ast_path)
+    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
+        <V as Fold>::fold_page_selector_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selectors(
-        &mut self,
-        node: Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PageSelector> {
-        <V as FoldAstPath>::fold_page_selectors(&mut **self, node, __ast_path)
+    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
+        <V as Fold>::fold_page_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
-        <V as FoldAstPath>::fold_percentage(&mut **self, node, __ast_path)
+    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
+        <V as Fold>::fold_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(
-        &mut self,
-        node: PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PseudoClassSelector {
-        <V as FoldAstPath>::fold_pseudo_class_selector(&mut **self, node, __ast_path)
+    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
+        <V as Fold>::fold_pseudo_class_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_class_selector_children(
         &mut self,
         node: PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoClassSelectorChildren {
-        <V as FoldAstPath>::fold_pseudo_class_selector_children(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_class_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_class_selector_childrens(
         &mut self,
         node: Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoClassSelectorChildren> {
-        <V as FoldAstPath>::fold_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_element_selector(
         &mut self,
         node: PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelector {
-        <V as FoldAstPath>::fold_pseudo_element_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_element_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_element_selector_children(
         &mut self,
         node: PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelectorChildren {
-        <V as FoldAstPath>::fold_pseudo_element_selector_children(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_element_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_element_selector_childrens(
         &mut self,
         node: Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoElementSelectorChildren> {
-        <V as FoldAstPath>::fold_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_qualified_rule(
-        &mut self,
-        node: QualifiedRule,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRule {
-        <V as FoldAstPath>::fold_qualified_rule(&mut **self, node, __ast_path)
+    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
+        <V as Fold>::fold_qualified_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_qualified_rule_prelude(
-        &mut self,
-        node: QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRulePrelude {
-        <V as FoldAstPath>::fold_qualified_rule_prelude(&mut **self, node, __ast_path)
+    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
+        <V as Fold>::fold_qualified_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_query_in_parens(
-        &mut self,
-        node: QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> QueryInParens {
-        <V as FoldAstPath>::fold_query_in_parens(&mut **self, node, __ast_path)
+    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
+        <V as Fold>::fold_query_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
-        <V as FoldAstPath>::fold_ratio(&mut **self, node, __ast_path)
+    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
+        <V as Fold>::fold_ratio(&mut **self, node)
     }
 
     #[inline]
-    fn fold_relative_selector(
-        &mut self,
-        node: RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelector {
-        <V as FoldAstPath>::fold_relative_selector(&mut **self, node, __ast_path)
+    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
+        <V as Fold>::fold_relative_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_relative_selector_list(
-        &mut self,
-        node: RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelectorList {
-        <V as FoldAstPath>::fold_relative_selector_list(&mut **self, node, __ast_path)
+    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
+        <V as Fold>::fold_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_relative_selectors(
-        &mut self,
-        node: Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<RelativeSelector> {
-        <V as FoldAstPath>::fold_relative_selectors(&mut **self, node, __ast_path)
+    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
+        <V as Fold>::fold_relative_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
-        <V as FoldAstPath>::fold_resolution(&mut **self, node, __ast_path)
+    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
+        <V as Fold>::fold_resolution(&mut **self, node)
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
-        <V as FoldAstPath>::fold_rule(&mut **self, node, __ast_path)
+    fn fold_rule(&mut self, node: Rule) -> Rule {
+        <V as Fold>::fold_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
-        <V as FoldAstPath>::fold_rules(&mut **self, node, __ast_path)
+    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
+        <V as Fold>::fold_rules(&mut **self, node)
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
-        <V as FoldAstPath>::fold_scope_range(&mut **self, node, __ast_path)
+    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
+        <V as Fold>::fold_scope_range(&mut **self, node)
     }
 
     #[inline]
-    fn fold_selector_list(
-        &mut self,
-        node: SelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> SelectorList {
-        <V as FoldAstPath>::fold_selector_list(&mut **self, node, __ast_path)
+    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
+        <V as Fold>::fold_selector_list(&mut **self, node)
     }
 
     #[inline]
     fn fold_sequence_of_custom_idents(
         &mut self,
         node: SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
     ) -> SequenceOfCustomIdents {
-        <V as FoldAstPath>::fold_sequence_of_custom_idents(&mut **self, node, __ast_path)
+        <V as Fold>::fold_sequence_of_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn fold_simple_block(
-        &mut self,
-        node: SimpleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleBlock {
-        <V as FoldAstPath>::fold_simple_block(&mut **self, node, __ast_path)
+    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
+        <V as Fold>::fold_simple_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature(
-        &mut self,
-        node: SizeFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeature {
-        <V as FoldAstPath>::fold_size_feature(&mut **self, node, __ast_path)
+    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
+        <V as Fold>::fold_size_feature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_boolean(
-        &mut self,
-        node: SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureBoolean {
-        <V as FoldAstPath>::fold_size_feature_boolean(&mut **self, node, __ast_path)
+    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
+        <V as Fold>::fold_size_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_name(
-        &mut self,
-        node: SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureName {
-        <V as FoldAstPath>::fold_size_feature_name(&mut **self, node, __ast_path)
+    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
+        <V as Fold>::fold_size_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_plain(
-        &mut self,
-        node: SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeaturePlain {
-        <V as FoldAstPath>::fold_size_feature_plain(&mut **self, node, __ast_path)
+    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
+        <V as Fold>::fold_size_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_range(
-        &mut self,
-        node: SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureRange {
-        <V as FoldAstPath>::fold_size_feature_range(&mut **self, node, __ast_path)
+    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
+        <V as Fold>::fold_size_feature_range(&mut **self, node)
     }
 
     #[inline]
     fn fold_size_feature_range_comparison(
         &mut self,
         node: SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeComparison {
-        <V as FoldAstPath>::fold_size_feature_range_comparison(&mut **self, node, __ast_path)
+        <V as Fold>::fold_size_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
     fn fold_size_feature_range_interval(
         &mut self,
         node: SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeInterval {
-        <V as FoldAstPath>::fold_size_feature_range_interval(&mut **self, node, __ast_path)
+        <V as Fold>::fold_size_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_value(
-        &mut self,
-        node: SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureValue {
-        <V as FoldAstPath>::fold_size_feature_value(&mut **self, node, __ast_path)
+    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
+        <V as Fold>::fold_size_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
-        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+        <V as Fold>::fold_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
-        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
+    fn fold_str(&mut self, node: Str) -> Str {
+        <V as Fold>::fold_str(&mut **self, node)
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
-        <V as FoldAstPath>::fold_style_block(&mut **self, node, __ast_path)
+    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
+        <V as Fold>::fold_style_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
-        <V as FoldAstPath>::fold_stylesheet(&mut **self, node, __ast_path)
+    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
+        <V as Fold>::fold_stylesheet(&mut **self, node)
     }
 
     #[inline]
-    fn fold_subclass_selector(
-        &mut self,
-        node: SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> SubclassSelector {
-        <V as FoldAstPath>::fold_subclass_selector(&mut **self, node, __ast_path)
+    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
+        <V as Fold>::fold_subclass_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_subclass_selectors(
-        &mut self,
-        node: Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SubclassSelector> {
-        <V as FoldAstPath>::fold_subclass_selectors(&mut **self, node, __ast_path)
+    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
+        <V as Fold>::fold_subclass_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_and(
-        &mut self,
-        node: SupportsAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsAnd {
-        <V as FoldAstPath>::fold_supports_and(&mut **self, node, __ast_path)
+    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
+        <V as Fold>::fold_supports_and(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_condition(
-        &mut self,
-        node: SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsCondition {
-        <V as FoldAstPath>::fold_supports_condition(&mut **self, node, __ast_path)
+    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
+        <V as Fold>::fold_supports_condition(&mut **self, node)
     }
 
     #[inline]
     fn fold_supports_condition_type(
         &mut self,
         node: SupportsConditionType,
-        __ast_path: &mut AstKindPath,
     ) -> SupportsConditionType {
-        <V as FoldAstPath>::fold_supports_condition_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_supports_condition_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_supports_condition_types(
         &mut self,
         node: Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<SupportsConditionType> {
-        <V as FoldAstPath>::fold_supports_condition_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_supports_condition_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_feature(
-        &mut self,
-        node: SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsFeature {
-        <V as FoldAstPath>::fold_supports_feature(&mut **self, node, __ast_path)
+    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
+        <V as Fold>::fold_supports_feature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_in_parens(
-        &mut self,
-        node: SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsInParens {
-        <V as FoldAstPath>::fold_supports_in_parens(&mut **self, node, __ast_path)
+    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
+        <V as Fold>::fold_supports_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_not(
-        &mut self,
-        node: SupportsNot,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsNot {
-        <V as FoldAstPath>::fold_supports_not(&mut **self, node, __ast_path)
+    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
+        <V as Fold>::fold_supports_not(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
-        <V as FoldAstPath>::fold_supports_or(&mut **self, node, __ast_path)
+    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
+        <V as Fold>::fold_supports_or(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tag_name_selector(
-        &mut self,
-        node: TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TagNameSelector {
-        <V as FoldAstPath>::fold_tag_name_selector(&mut **self, node, __ast_path)
+    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
+        <V as Fold>::fold_tag_name_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
-        <V as FoldAstPath>::fold_time(&mut **self, node, __ast_path)
+    fn fold_time(&mut self, node: Time) -> Time {
+        <V as Fold>::fold_time(&mut **self, node)
     }
 
     #[inline]
-    fn fold_time_percentage(
-        &mut self,
-        node: TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> TimePercentage {
-        <V as FoldAstPath>::fold_time_percentage(&mut **self, node, __ast_path)
+    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
+        <V as Fold>::fold_time_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
-        <V as FoldAstPath>::fold_token(&mut **self, node, __ast_path)
+    fn fold_token(&mut self, node: Token) -> Token {
+        <V as Fold>::fold_token(&mut **self, node)
     }
 
     #[inline]
-    fn fold_token_and_span(
-        &mut self,
-        node: TokenAndSpan,
-        __ast_path: &mut AstKindPath,
-    ) -> TokenAndSpan {
-        <V as FoldAstPath>::fold_token_and_span(&mut **self, node, __ast_path)
+    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
+        <V as Fold>::fold_token_and_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_type_selector(
-        &mut self,
-        node: TypeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TypeSelector {
-        <V as FoldAstPath>::fold_type_selector(&mut **self, node, __ast_path)
+    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
+        <V as Fold>::fold_type_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unicode_range(
-        &mut self,
-        node: UnicodeRange,
-        __ast_path: &mut AstKindPath,
-    ) -> UnicodeRange {
-        <V as FoldAstPath>::fold_unicode_range(&mut **self, node, __ast_path)
+    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
+        <V as Fold>::fold_unicode_range(&mut **self, node)
     }
 
     #[inline]
-    fn fold_universal_selector(
-        &mut self,
-        node: UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> UniversalSelector {
-        <V as FoldAstPath>::fold_universal_selector(&mut **self, node, __ast_path)
+    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
+        <V as Fold>::fold_universal_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unknown_dimension(
-        &mut self,
-        node: UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) -> UnknownDimension {
-        <V as FoldAstPath>::fold_unknown_dimension(&mut **self, node, __ast_path)
+    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
+        <V as Fold>::fold_unknown_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
-        <V as FoldAstPath>::fold_url(&mut **self, node, __ast_path)
+    fn fold_url(&mut self, node: Url) -> Url {
+        <V as Fold>::fold_url(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_key_value(
-        &mut self,
-        node: UrlKeyValue,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlKeyValue {
-        <V as FoldAstPath>::fold_url_key_value(&mut **self, node, __ast_path)
+    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
+        <V as Fold>::fold_url_key_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_modifier(
-        &mut self,
-        node: UrlModifier,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlModifier {
-        <V as FoldAstPath>::fold_url_modifier(&mut **self, node, __ast_path)
+    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
+        <V as Fold>::fold_url_modifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_modifiers(
-        &mut self,
-        node: Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<UrlModifier> {
-        <V as FoldAstPath>::fold_url_modifiers(&mut **self, node, __ast_path)
+    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
+        <V as Fold>::fold_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
-        <V as FoldAstPath>::fold_url_value(&mut **self, node, __ast_path)
+    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
+        <V as Fold>::fold_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_value_raw(
-        &mut self,
-        node: UrlValueRaw,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlValueRaw {
-        <V as FoldAstPath>::fold_url_value_raw(&mut **self, node, __ast_path)
+    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
+        <V as Fold>::fold_url_value_raw(&mut **self, node)
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
-        <V as FoldAstPath>::fold_wq_name(&mut **self, node, __ast_path)
+    fn fold_wq_name(&mut self, node: WqName) -> WqName {
+        <V as Fold>::fold_wq_name(&mut **self, node)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> FoldAstPath for Box<V>
+impl<V> Fold for Box<V>
 where
-    V: ?Sized + FoldAstPath,
+    V: ?Sized + Fold,
 {
     #[inline]
-    fn fold_absolute_color_base(
-        &mut self,
-        node: AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) -> AbsoluteColorBase {
-        <V as FoldAstPath>::fold_absolute_color_base(&mut **self, node, __ast_path)
+    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
+        <V as Fold>::fold_absolute_color_base(&mut **self, node)
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
-        <V as FoldAstPath>::fold_alpha_value(&mut **self, node, __ast_path)
+    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
+        <V as Fold>::fold_alpha_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
-        <V as FoldAstPath>::fold_an_plus_b(&mut **self, node, __ast_path)
+    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
+        <V as Fold>::fold_an_plus_b(&mut **self, node)
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(
-        &mut self,
-        node: AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) -> AnPlusBNotation {
-        <V as FoldAstPath>::fold_an_plus_b_notation(&mut **self, node, __ast_path)
+    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
+        <V as Fold>::fold_an_plus_b_notation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
-        <V as FoldAstPath>::fold_angle(&mut **self, node, __ast_path)
+    fn fold_angle(&mut self, node: Angle) -> Angle {
+        <V as Fold>::fold_angle(&mut **self, node)
     }
 
     #[inline]
-    fn fold_angle_percentage(
-        &mut self,
-        node: AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> AnglePercentage {
-        <V as FoldAstPath>::fold_angle_percentage(&mut **self, node, __ast_path)
+    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
+        <V as Fold>::fold_angle_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_any_namespace(
-        &mut self,
-        node: AnyNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> AnyNamespace {
-        <V as FoldAstPath>::fold_any_namespace(&mut **self, node, __ast_path)
+    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
+        <V as Fold>::fold_any_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
-        <V as FoldAstPath>::fold_at_rule(&mut **self, node, __ast_path)
+    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
+        <V as Fold>::fold_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
-        <V as FoldAstPath>::fold_at_rule_name(&mut **self, node, __ast_path)
+    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
+        <V as Fold>::fold_at_rule_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_at_rule_prelude(
-        &mut self,
-        node: AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> AtRulePrelude {
-        <V as FoldAstPath>::fold_at_rule_prelude(&mut **self, node, __ast_path)
+    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
+        <V as Fold>::fold_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
-        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+        <V as Fold>::fold_atom(&mut **self, node)
     }
 
     #[inline]
-    fn fold_attribute_selector(
-        &mut self,
-        node: AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> AttributeSelector {
-        <V as FoldAstPath>::fold_attribute_selector(&mut **self, node, __ast_path)
+    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
+        <V as Fold>::fold_attribute_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_matcher(
         &mut self,
         node: AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcher {
-        <V as FoldAstPath>::fold_attribute_selector_matcher(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_matcher_value(
         &mut self,
         node: AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcherValue {
-        <V as FoldAstPath>::fold_attribute_selector_matcher_value(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_matcher_value(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_modifier(
         &mut self,
         node: AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorModifier {
-        <V as FoldAstPath>::fold_attribute_selector_modifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
     fn fold_attribute_selector_value(
         &mut self,
         node: AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorValue {
-        <V as FoldAstPath>::fold_attribute_selector_value(&mut **self, node, __ast_path)
+        <V as Fold>::fold_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
-        <V as FoldAstPath>::fold_bin_op(&mut **self, node, __ast_path)
+    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
+        <V as Fold>::fold_bin_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_operator(
-        &mut self,
-        node: CalcOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperator {
-        <V as FoldAstPath>::fold_calc_operator(&mut **self, node, __ast_path)
+    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
+        <V as Fold>::fold_calc_operator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_operator_type(
-        &mut self,
-        node: CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperatorType {
-        <V as FoldAstPath>::fold_calc_operator_type(&mut **self, node, __ast_path)
+    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
+        <V as Fold>::fold_calc_operator_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_product(
-        &mut self,
-        node: CalcProduct,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcProduct {
-        <V as FoldAstPath>::fold_calc_product(&mut **self, node, __ast_path)
+    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
+        <V as Fold>::fold_calc_product(&mut **self, node)
     }
 
     #[inline]
     fn fold_calc_product_or_operator(
         &mut self,
         node: CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
     ) -> CalcProductOrOperator {
-        <V as FoldAstPath>::fold_calc_product_or_operator(&mut **self, node, __ast_path)
+        <V as Fold>::fold_calc_product_or_operator(&mut **self, node)
     }
 
     #[inline]
     fn fold_calc_product_or_operators(
         &mut self,
         node: Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcProductOrOperator> {
-        <V as FoldAstPath>::fold_calc_product_or_operators(&mut **self, node, __ast_path)
+        <V as Fold>::fold_calc_product_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
-        <V as FoldAstPath>::fold_calc_sum(&mut **self, node, __ast_path)
+    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
+        <V as Fold>::fold_calc_sum(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
-        <V as FoldAstPath>::fold_calc_value(&mut **self, node, __ast_path)
+    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
+        <V as Fold>::fold_calc_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(
-        &mut self,
-        node: CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcValueOrOperator {
-        <V as FoldAstPath>::fold_calc_value_or_operator(&mut **self, node, __ast_path)
+    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
+        <V as Fold>::fold_calc_value_or_operator(&mut **self, node)
     }
 
     #[inline]
     fn fold_calc_value_or_operators(
         &mut self,
         node: Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcValueOrOperator> {
-        <V as FoldAstPath>::fold_calc_value_or_operators(&mut **self, node, __ast_path)
+        <V as Fold>::fold_calc_value_or_operators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_selector(
-        &mut self,
-        node: ClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassSelector {
-        <V as FoldAstPath>::fold_class_selector(&mut **self, node, __ast_path)
+    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
+        <V as Fold>::fold_class_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_cmyk_component(
-        &mut self,
-        node: CmykComponent,
-        __ast_path: &mut AstKindPath,
-    ) -> CmykComponent {
-        <V as FoldAstPath>::fold_cmyk_component(&mut **self, node, __ast_path)
+    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
+        <V as Fold>::fold_cmyk_component(&mut **self, node)
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
-        <V as FoldAstPath>::fold_color(&mut **self, node, __ast_path)
+    fn fold_color(&mut self, node: Color) -> Color {
+        <V as Fold>::fold_color(&mut **self, node)
     }
 
     #[inline]
-    fn fold_color_profile_name(
-        &mut self,
-        node: ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) -> ColorProfileName {
-        <V as FoldAstPath>::fold_color_profile_name(&mut **self, node, __ast_path)
+    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
+        <V as Fold>::fold_color_profile_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
-        <V as FoldAstPath>::fold_combinator(&mut **self, node, __ast_path)
+    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
+        <V as Fold>::fold_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_combinator_value(
-        &mut self,
-        node: CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) -> CombinatorValue {
-        <V as FoldAstPath>::fold_combinator_value(&mut **self, node, __ast_path)
+    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
+        <V as Fold>::fold_combinator_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_complex_selector(
-        &mut self,
-        node: ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ComplexSelector {
-        <V as FoldAstPath>::fold_complex_selector(&mut **self, node, __ast_path)
+    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
+        <V as Fold>::fold_complex_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_complex_selector_children(
         &mut self,
         node: ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> ComplexSelectorChildren {
-        <V as FoldAstPath>::fold_complex_selector_children(&mut **self, node, __ast_path)
+        <V as Fold>::fold_complex_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn fold_complex_selector_childrens(
         &mut self,
         node: Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ComplexSelectorChildren> {
-        <V as FoldAstPath>::fold_complex_selector_childrens(&mut **self, node, __ast_path)
+        <V as Fold>::fold_complex_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_complex_selectors(
-        &mut self,
-        node: Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComplexSelector> {
-        <V as FoldAstPath>::fold_complex_selectors(&mut **self, node, __ast_path)
+    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
+        <V as Fold>::fold_complex_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_component_value(
-        &mut self,
-        node: ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) -> ComponentValue {
-        <V as FoldAstPath>::fold_component_value(&mut **self, node, __ast_path)
+    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
+        <V as Fold>::fold_component_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_component_values(
-        &mut self,
-        node: Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComponentValue> {
-        <V as FoldAstPath>::fold_component_values(&mut **self, node, __ast_path)
+    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
+        <V as Fold>::fold_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn fold_compound_selector(
-        &mut self,
-        node: CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelector {
-        <V as FoldAstPath>::fold_compound_selector(&mut **self, node, __ast_path)
+    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
+        <V as Fold>::fold_compound_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_compound_selector_list(
-        &mut self,
-        node: CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelectorList {
-        <V as FoldAstPath>::fold_compound_selector_list(&mut **self, node, __ast_path)
+    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
+        <V as Fold>::fold_compound_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_compound_selectors(
-        &mut self,
-        node: Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CompoundSelector> {
-        <V as FoldAstPath>::fold_compound_selectors(&mut **self, node, __ast_path)
+    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
+        <V as Fold>::fold_compound_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_condition(
-        &mut self,
-        node: ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerCondition {
-        <V as FoldAstPath>::fold_container_condition(&mut **self, node, __ast_path)
+    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
+        <V as Fold>::fold_container_condition(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_name(
-        &mut self,
-        node: ContainerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerName {
-        <V as FoldAstPath>::fold_container_name(&mut **self, node, __ast_path)
+    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
+        <V as Fold>::fold_container_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query(
-        &mut self,
-        node: ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQuery {
-        <V as FoldAstPath>::fold_container_query(&mut **self, node, __ast_path)
+    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
+        <V as Fold>::fold_container_query(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_and(
-        &mut self,
-        node: ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryAnd {
-        <V as FoldAstPath>::fold_container_query_and(&mut **self, node, __ast_path)
+    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
+        <V as Fold>::fold_container_query_and(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_not(
-        &mut self,
-        node: ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryNot {
-        <V as FoldAstPath>::fold_container_query_not(&mut **self, node, __ast_path)
+    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
+        <V as Fold>::fold_container_query_not(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_or(
-        &mut self,
-        node: ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryOr {
-        <V as FoldAstPath>::fold_container_query_or(&mut **self, node, __ast_path)
+    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
+        <V as Fold>::fold_container_query_or(&mut **self, node)
     }
 
     #[inline]
-    fn fold_container_query_type(
-        &mut self,
-        node: ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryType {
-        <V as FoldAstPath>::fold_container_query_type(&mut **self, node, __ast_path)
+    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
+        <V as Fold>::fold_container_query_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_container_query_types(
         &mut self,
         node: Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ContainerQueryType> {
-        <V as FoldAstPath>::fold_container_query_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_container_query_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_highlight_name(
-        &mut self,
-        node: CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomHighlightName {
-        <V as FoldAstPath>::fold_custom_highlight_name(&mut **self, node, __ast_path)
+    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
+        <V as Fold>::fold_custom_highlight_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_ident(
-        &mut self,
-        node: CustomIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomIdent {
-        <V as FoldAstPath>::fold_custom_ident(&mut **self, node, __ast_path)
+    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
+        <V as Fold>::fold_custom_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_idents(
-        &mut self,
-        node: Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CustomIdent> {
-        <V as FoldAstPath>::fold_custom_idents(&mut **self, node, __ast_path)
+    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
+        <V as Fold>::fold_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_media_query(
-        &mut self,
-        node: CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomMediaQuery {
-        <V as FoldAstPath>::fold_custom_media_query(&mut **self, node, __ast_path)
+    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
+        <V as Fold>::fold_custom_media_query(&mut **self, node)
     }
 
     #[inline]
     fn fold_custom_media_query_media_type(
         &mut self,
         node: CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
     ) -> CustomMediaQueryMediaType {
-        <V as FoldAstPath>::fold_custom_media_query_media_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_custom_media_query_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_custom_property_name(
-        &mut self,
-        node: CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomPropertyName {
-        <V as FoldAstPath>::fold_custom_property_name(&mut **self, node, __ast_path)
+    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
+        <V as Fold>::fold_custom_property_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_dashed_ident(
-        &mut self,
-        node: DashedIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> DashedIdent {
-        <V as FoldAstPath>::fold_dashed_ident(&mut **self, node, __ast_path)
+    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
+        <V as Fold>::fold_dashed_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
-        <V as FoldAstPath>::fold_declaration(&mut **self, node, __ast_path)
+    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
+        <V as Fold>::fold_declaration(&mut **self, node)
     }
 
     #[inline]
-    fn fold_declaration_name(
-        &mut self,
-        node: DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationName {
-        <V as FoldAstPath>::fold_declaration_name(&mut **self, node, __ast_path)
+    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
+        <V as Fold>::fold_declaration_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(
-        &mut self,
-        node: DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationOrAtRule {
-        <V as FoldAstPath>::fold_declaration_or_at_rule(&mut **self, node, __ast_path)
+    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
+        <V as Fold>::fold_declaration_or_at_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
-        <V as FoldAstPath>::fold_delimiter(&mut **self, node, __ast_path)
+    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
+        <V as Fold>::fold_delimiter(&mut **self, node)
     }
 
     #[inline]
-    fn fold_delimiter_value(
-        &mut self,
-        node: DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) -> DelimiterValue {
-        <V as FoldAstPath>::fold_delimiter_value(&mut **self, node, __ast_path)
+    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
+        <V as Fold>::fold_delimiter_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
-        <V as FoldAstPath>::fold_dimension(&mut **self, node, __ast_path)
+    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
+        <V as Fold>::fold_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn fold_dimension_token(
-        &mut self,
-        node: DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) -> DimensionToken {
-        <V as FoldAstPath>::fold_dimension_token(&mut **self, node, __ast_path)
+    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
+        <V as Fold>::fold_dimension_token(&mut **self, node)
     }
 
     #[inline]
-    fn fold_document_prelude(
-        &mut self,
-        node: DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> DocumentPrelude {
-        <V as FoldAstPath>::fold_document_prelude(&mut **self, node, __ast_path)
+    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
+        <V as Fold>::fold_document_prelude(&mut **self, node)
     }
 
     #[inline]
     fn fold_document_prelude_matching_function(
         &mut self,
         node: DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) -> DocumentPreludeMatchingFunction {
-        <V as FoldAstPath>::fold_document_prelude_matching_function(&mut **self, node, __ast_path)
+        <V as Fold>::fold_document_prelude_matching_function(&mut **self, node)
     }
 
     #[inline]
     fn fold_document_prelude_matching_functions(
         &mut self,
         node: Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<DocumentPreludeMatchingFunction> {
-        <V as FoldAstPath>::fold_document_prelude_matching_functions(&mut **self, node, __ast_path)
+        <V as Fold>::fold_document_prelude_matching_functions(&mut **self, node)
     }
 
     #[inline]
-    fn fold_extension_name(
-        &mut self,
-        node: ExtensionName,
-        __ast_path: &mut AstKindPath,
-    ) -> ExtensionName {
-        <V as FoldAstPath>::fold_extension_name(&mut **self, node, __ast_path)
+    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
+        <V as Fold>::fold_extension_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
-        <V as FoldAstPath>::fold_family_name(&mut **self, node, __ast_path)
+    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
+        <V as Fold>::fold_family_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_family_names(
-        &mut self,
-        node: Vec<FamilyName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<FamilyName> {
-        <V as FoldAstPath>::fold_family_names(&mut **self, node, __ast_path)
+    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
+        <V as Fold>::fold_family_names(&mut **self, node)
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
-        <V as FoldAstPath>::fold_flex(&mut **self, node, __ast_path)
+    fn fold_flex(&mut self, node: Flex) -> Flex {
+        <V as Fold>::fold_flex(&mut **self, node)
     }
 
     #[inline]
     fn fold_font_feature_values_prelude(
         &mut self,
         node: FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
     ) -> FontFeatureValuesPrelude {
-        <V as FoldAstPath>::fold_font_feature_values_prelude(&mut **self, node, __ast_path)
+        <V as Fold>::fold_font_feature_values_prelude(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_complex_selector(
         &mut self,
         node: ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingComplexSelector {
-        <V as FoldAstPath>::fold_forgiving_complex_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_complex_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_complex_selectors(
         &mut self,
         node: Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingComplexSelector> {
-        <V as FoldAstPath>::fold_forgiving_complex_selectors(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_complex_selectors(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_relative_selector(
         &mut self,
         node: ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelector {
-        <V as FoldAstPath>::fold_forgiving_relative_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_relative_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_relative_selector_list(
         &mut self,
         node: ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelectorList {
-        <V as FoldAstPath>::fold_forgiving_relative_selector_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_relative_selectors(
         &mut self,
         node: Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingRelativeSelector> {
-        <V as FoldAstPath>::fold_forgiving_relative_selectors(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_relative_selectors(&mut **self, node)
     }
 
     #[inline]
     fn fold_forgiving_selector_list(
         &mut self,
         node: ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingSelectorList {
-        <V as FoldAstPath>::fold_forgiving_selector_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
-        <V as FoldAstPath>::fold_frequency(&mut **self, node, __ast_path)
+    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
+        <V as Fold>::fold_frequency(&mut **self, node)
     }
 
     #[inline]
-    fn fold_frequency_percentage(
-        &mut self,
-        node: FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> FrequencyPercentage {
-        <V as FoldAstPath>::fold_frequency_percentage(&mut **self, node, __ast_path)
+    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
+        <V as Fold>::fold_frequency_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
-        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
+    fn fold_function(&mut self, node: Function) -> Function {
+        <V as Fold>::fold_function(&mut **self, node)
     }
 
     #[inline]
-    fn fold_function_name(
-        &mut self,
-        node: FunctionName,
-        __ast_path: &mut AstKindPath,
-    ) -> FunctionName {
-        <V as FoldAstPath>::fold_function_name(&mut **self, node, __ast_path)
+    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
+        <V as Fold>::fold_function_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_general_enclosed(
-        &mut self,
-        node: GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) -> GeneralEnclosed {
-        <V as FoldAstPath>::fold_general_enclosed(&mut **self, node, __ast_path)
+    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
+        <V as Fold>::fold_general_enclosed(&mut **self, node)
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
-        <V as FoldAstPath>::fold_hex_color(&mut **self, node, __ast_path)
+    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
+        <V as Fold>::fold_hex_color(&mut **self, node)
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
-        <V as FoldAstPath>::fold_hue(&mut **self, node, __ast_path)
+    fn fold_hue(&mut self, node: Hue) -> Hue {
+        <V as Fold>::fold_hue(&mut **self, node)
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
-        <V as FoldAstPath>::fold_id_selector(&mut **self, node, __ast_path)
+    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
+        <V as Fold>::fold_id_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
-        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
+    fn fold_ident(&mut self, node: Ident) -> Ident {
+        <V as Fold>::fold_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
-        <V as FoldAstPath>::fold_idents(&mut **self, node, __ast_path)
+    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
+        <V as Fold>::fold_idents(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_conditions(
-        &mut self,
-        node: ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportConditions {
-        <V as FoldAstPath>::fold_import_conditions(&mut **self, node, __ast_path)
+    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
+        <V as Fold>::fold_import_conditions(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
-        <V as FoldAstPath>::fold_import_href(&mut **self, node, __ast_path)
+    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
+        <V as Fold>::fold_import_href(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_layer_name(
-        &mut self,
-        node: ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportLayerName {
-        <V as FoldAstPath>::fold_import_layer_name(&mut **self, node, __ast_path)
+    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
+        <V as Fold>::fold_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_prelude(
-        &mut self,
-        node: ImportPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPrelude {
-        <V as FoldAstPath>::fold_import_prelude(&mut **self, node, __ast_path)
+    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
+        <V as Fold>::fold_import_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_important_flag(
-        &mut self,
-        node: ImportantFlag,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportantFlag {
-        <V as FoldAstPath>::fold_important_flag(&mut **self, node, __ast_path)
+    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
+        <V as Fold>::fold_important_flag(&mut **self, node)
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
-        <V as FoldAstPath>::fold_integer(&mut **self, node, __ast_path)
+    fn fold_integer(&mut self, node: Integer) -> Integer {
+        <V as Fold>::fold_integer(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframe_block(
-        &mut self,
-        node: KeyframeBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeBlock {
-        <V as FoldAstPath>::fold_keyframe_block(&mut **self, node, __ast_path)
+    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
+        <V as Fold>::fold_keyframe_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframe_selector(
-        &mut self,
-        node: KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeSelector {
-        <V as FoldAstPath>::fold_keyframe_selector(&mut **self, node, __ast_path)
+    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
+        <V as Fold>::fold_keyframe_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframe_selectors(
-        &mut self,
-        node: Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<KeyframeSelector> {
-        <V as FoldAstPath>::fold_keyframe_selectors(&mut **self, node, __ast_path)
+    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
+        <V as Fold>::fold_keyframe_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_keyframes_name(
-        &mut self,
-        node: KeyframesName,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframesName {
-        <V as FoldAstPath>::fold_keyframes_name(&mut **self, node, __ast_path)
+    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
+        <V as Fold>::fold_keyframes_name(&mut **self, node)
     }
 
     #[inline]
     fn fold_keyframes_pseudo_function(
         &mut self,
         node: KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoFunction {
-        <V as FoldAstPath>::fold_keyframes_pseudo_function(&mut **self, node, __ast_path)
+        <V as Fold>::fold_keyframes_pseudo_function(&mut **self, node)
     }
 
     #[inline]
     fn fold_keyframes_pseudo_prefix(
         &mut self,
         node: KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoPrefix {
-        <V as FoldAstPath>::fold_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
+        <V as Fold>::fold_keyframes_pseudo_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
-        <V as FoldAstPath>::fold_layer_name(&mut **self, node, __ast_path)
+    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
+        <V as Fold>::fold_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_name_list(
-        &mut self,
-        node: LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerNameList {
-        <V as FoldAstPath>::fold_layer_name_list(&mut **self, node, __ast_path)
+    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
+        <V as Fold>::fold_layer_name_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_names(
-        &mut self,
-        node: Vec<LayerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<LayerName> {
-        <V as FoldAstPath>::fold_layer_names(&mut **self, node, __ast_path)
+    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
+        <V as Fold>::fold_layer_names(&mut **self, node)
     }
 
     #[inline]
-    fn fold_layer_prelude(
-        &mut self,
-        node: LayerPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerPrelude {
-        <V as FoldAstPath>::fold_layer_prelude(&mut **self, node, __ast_path)
+    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
+        <V as Fold>::fold_layer_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
-        <V as FoldAstPath>::fold_length(&mut **self, node, __ast_path)
+    fn fold_length(&mut self, node: Length) -> Length {
+        <V as Fold>::fold_length(&mut **self, node)
     }
 
     #[inline]
-    fn fold_length_percentage(
-        &mut self,
-        node: LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> LengthPercentage {
-        <V as FoldAstPath>::fold_length_percentage(&mut **self, node, __ast_path)
+    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
+        <V as Fold>::fold_length_percentage(&mut **self, node)
     }
 
     #[inline]
     fn fold_list_of_component_values(
         &mut self,
         node: ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
     ) -> ListOfComponentValues {
-        <V as FoldAstPath>::fold_list_of_component_values(&mut **self, node, __ast_path)
+        <V as Fold>::fold_list_of_component_values(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
-        <V as FoldAstPath>::fold_media_and(&mut **self, node, __ast_path)
+    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
+        <V as Fold>::fold_media_and(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_condition(
-        &mut self,
-        node: MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaCondition {
-        <V as FoldAstPath>::fold_media_condition(&mut **self, node, __ast_path)
+    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
+        <V as Fold>::fold_media_condition(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_all_type(
         &mut self,
         node: MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionAllType {
-        <V as FoldAstPath>::fold_media_condition_all_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_all_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_all_types(
         &mut self,
         node: Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionAllType> {
-        <V as FoldAstPath>::fold_media_condition_all_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_all_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_condition_type(
-        &mut self,
-        node: MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaConditionType {
-        <V as FoldAstPath>::fold_media_condition_type(&mut **self, node, __ast_path)
+    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
+        <V as Fold>::fold_media_condition_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_without_or(
         &mut self,
         node: MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOr {
-        <V as FoldAstPath>::fold_media_condition_without_or(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_without_or(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_without_or_type(
         &mut self,
         node: MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOrType {
-        <V as FoldAstPath>::fold_media_condition_without_or_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_without_or_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_condition_without_or_types(
         &mut self,
         node: Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionWithoutOrType> {
-        <V as FoldAstPath>::fold_media_condition_without_or_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_condition_without_or_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature(
-        &mut self,
-        node: MediaFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeature {
-        <V as FoldAstPath>::fold_media_feature(&mut **self, node, __ast_path)
+    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
+        <V as Fold>::fold_media_feature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_boolean(
-        &mut self,
-        node: MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureBoolean {
-        <V as FoldAstPath>::fold_media_feature_boolean(&mut **self, node, __ast_path)
+    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
+        <V as Fold>::fold_media_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_name(
-        &mut self,
-        node: MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureName {
-        <V as FoldAstPath>::fold_media_feature_name(&mut **self, node, __ast_path)
+    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
+        <V as Fold>::fold_media_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_plain(
-        &mut self,
-        node: MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeaturePlain {
-        <V as FoldAstPath>::fold_media_feature_plain(&mut **self, node, __ast_path)
+    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
+        <V as Fold>::fold_media_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_range(
-        &mut self,
-        node: MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureRange {
-        <V as FoldAstPath>::fold_media_feature_range(&mut **self, node, __ast_path)
+    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
+        <V as Fold>::fold_media_feature_range(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_feature_range_comparison(
         &mut self,
         node: MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeComparison {
-        <V as FoldAstPath>::fold_media_feature_range_comparison(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
     fn fold_media_feature_range_interval(
         &mut self,
         node: MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeInterval {
-        <V as FoldAstPath>::fold_media_feature_range_interval(&mut **self, node, __ast_path)
+        <V as Fold>::fold_media_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_feature_value(
-        &mut self,
-        node: MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureValue {
-        <V as FoldAstPath>::fold_media_feature_value(&mut **self, node, __ast_path)
+    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
+        <V as Fold>::fold_media_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_in_parens(
-        &mut self,
-        node: MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaInParens {
-        <V as FoldAstPath>::fold_media_in_parens(&mut **self, node, __ast_path)
+    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
+        <V as Fold>::fold_media_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
-        <V as FoldAstPath>::fold_media_not(&mut **self, node, __ast_path)
+    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
+        <V as Fold>::fold_media_not(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
-        <V as FoldAstPath>::fold_media_or(&mut **self, node, __ast_path)
+    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
+        <V as Fold>::fold_media_or(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
-        <V as FoldAstPath>::fold_media_query(&mut **self, node, __ast_path)
+    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
+        <V as Fold>::fold_media_query(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_query_list(
-        &mut self,
-        node: MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaQueryList {
-        <V as FoldAstPath>::fold_media_query_list(&mut **self, node, __ast_path)
+    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
+        <V as Fold>::fold_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_querys(
-        &mut self,
-        node: Vec<MediaQuery>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<MediaQuery> {
-        <V as FoldAstPath>::fold_media_querys(&mut **self, node, __ast_path)
+    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
+        <V as Fold>::fold_media_querys(&mut **self, node)
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
-        <V as FoldAstPath>::fold_media_type(&mut **self, node, __ast_path)
+    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
+        <V as Fold>::fold_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_named_namespace(
-        &mut self,
-        node: NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedNamespace {
-        <V as FoldAstPath>::fold_named_namespace(&mut **self, node, __ast_path)
+    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
+        <V as Fold>::fold_named_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
-        <V as FoldAstPath>::fold_namespace(&mut **self, node, __ast_path)
+    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
+        <V as Fold>::fold_namespace(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace_prefix(
-        &mut self,
-        node: NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrefix {
-        <V as FoldAstPath>::fold_namespace_prefix(&mut **self, node, __ast_path)
+    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
+        <V as Fold>::fold_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace_prelude(
-        &mut self,
-        node: NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrelude {
-        <V as FoldAstPath>::fold_namespace_prelude(&mut **self, node, __ast_path)
+    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
+        <V as Fold>::fold_namespace_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(
-        &mut self,
-        node: NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePreludeUri {
-        <V as FoldAstPath>::fold_namespace_prelude_uri(&mut **self, node, __ast_path)
+    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
+        <V as Fold>::fold_namespace_prelude_uri(&mut **self, node)
     }
 
     #[inline]
-    fn fold_nesting_selector(
-        &mut self,
-        node: NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> NestingSelector {
-        <V as FoldAstPath>::fold_nesting_selector(&mut **self, node, __ast_path)
+    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
+        <V as Fold>::fold_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
-        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
+    fn fold_number(&mut self, node: Number) -> Number {
+        <V as Fold>::fold_number(&mut **self, node)
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
-        <V as FoldAstPath>::fold_number_type(&mut **self, node, __ast_path)
+    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
+        <V as Fold>::fold_number_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_at_rule_prelude(
         &mut self,
         node: Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<AtRulePrelude>> {
-        <V as FoldAstPath>::fold_opt_at_rule_prelude(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_at_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
-        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+        <V as Fold>::fold_opt_atom(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_attribute_selector_matcher(
         &mut self,
         node: Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorMatcher> {
-        <V as FoldAstPath>::fold_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_attribute_selector_matcher(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_attribute_selector_modifier(
         &mut self,
         node: Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorModifier> {
-        <V as FoldAstPath>::fold_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_attribute_selector_modifier(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_attribute_selector_value(
         &mut self,
         node: Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorValue> {
-        <V as FoldAstPath>::fold_opt_attribute_selector_value(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_attribute_selector_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_combinator(
-        &mut self,
-        node: Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Combinator> {
-        <V as FoldAstPath>::fold_opt_combinator(&mut **self, node, __ast_path)
+    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
+        <V as Fold>::fold_opt_combinator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_container_name(
-        &mut self,
-        node: Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ContainerName> {
-        <V as FoldAstPath>::fold_opt_container_name(&mut **self, node, __ast_path)
+    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
+        <V as Fold>::fold_opt_container_name(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_forgiving_selector_list(
         &mut self,
         node: Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ForgivingSelectorList> {
-        <V as FoldAstPath>::fold_opt_forgiving_selector_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_forgiving_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_function(
-        &mut self,
-        node: Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Function>> {
-        <V as FoldAstPath>::fold_opt_function(&mut **self, node, __ast_path)
+    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
+        <V as Fold>::fold_opt_function(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
-        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+        <V as Fold>::fold_opt_ident(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_import_conditions(
         &mut self,
         node: Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportConditions>> {
-        <V as FoldAstPath>::fold_opt_import_conditions(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_import_conditions(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_import_layer_name(
         &mut self,
         node: Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportLayerName>> {
-        <V as FoldAstPath>::fold_opt_import_layer_name(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_import_layer_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_important_flag(
-        &mut self,
-        node: Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ImportantFlag> {
-        <V as FoldAstPath>::fold_opt_important_flag(&mut **self, node, __ast_path)
+    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
+        <V as Fold>::fold_opt_important_flag(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_media_condition_type(
         &mut self,
         node: Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaConditionType>> {
-        <V as FoldAstPath>::fold_opt_media_condition_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_media_condition_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_media_query_list(
         &mut self,
         node: Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaQueryList>> {
-        <V as FoldAstPath>::fold_opt_media_query_list(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_media_query_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_media_type(
-        &mut self,
-        node: Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<MediaType> {
-        <V as FoldAstPath>::fold_opt_media_type(&mut **self, node, __ast_path)
+    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
+        <V as Fold>::fold_opt_media_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_namespace(
-        &mut self,
-        node: Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Namespace> {
-        <V as FoldAstPath>::fold_opt_namespace(&mut **self, node, __ast_path)
+    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
+        <V as Fold>::fold_opt_namespace(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_namespace_prefix(
         &mut self,
         node: Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NamespacePrefix> {
-        <V as FoldAstPath>::fold_opt_namespace_prefix(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_namespace_prefix(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_nesting_selector(
         &mut self,
         node: Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NestingSelector> {
-        <V as FoldAstPath>::fold_opt_nesting_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_nesting_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_number(
-        &mut self,
-        node: Option<Number>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Number> {
-        <V as FoldAstPath>::fold_opt_number(&mut **self, node, __ast_path)
+    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
+        <V as Fold>::fold_opt_number(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_page_selector_pseudos(
         &mut self,
         node: Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PageSelectorPseudo>> {
-        <V as FoldAstPath>::fold_opt_page_selector_pseudos(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_page_selector_type(
         &mut self,
         node: Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<PageSelectorType> {
-        <V as FoldAstPath>::fold_opt_page_selector_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_page_selector_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoClassSelectorChildren>> {
-        <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoElementSelectorChildren>> {
-        <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as Fold>::fold_opt_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_simple_block(
-        &mut self,
-        node: Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<SimpleBlock> {
-        <V as FoldAstPath>::fold_opt_simple_block(&mut **self, node, __ast_path)
+    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
+        <V as Fold>::fold_opt_simple_block(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_type_selector(
         &mut self,
         node: Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TypeSelector>> {
-        <V as FoldAstPath>::fold_opt_type_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_type_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_url_modifiers(
         &mut self,
         node: Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<UrlModifier>> {
-        <V as FoldAstPath>::fold_opt_url_modifiers(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_url_value(
-        &mut self,
-        node: Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<UrlValue>> {
-        <V as FoldAstPath>::fold_opt_url_value(&mut **self, node, __ast_path)
+    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
+        <V as Fold>::fold_opt_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector(
-        &mut self,
-        node: PageSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelector {
-        <V as FoldAstPath>::fold_page_selector(&mut **self, node, __ast_path)
+    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
+        <V as Fold>::fold_page_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector_list(
-        &mut self,
-        node: PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorList {
-        <V as FoldAstPath>::fold_page_selector_list(&mut **self, node, __ast_path)
+    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
+        <V as Fold>::fold_page_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(
-        &mut self,
-        node: PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorPseudo {
-        <V as FoldAstPath>::fold_page_selector_pseudo(&mut **self, node, __ast_path)
+    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
+        <V as Fold>::fold_page_selector_pseudo(&mut **self, node)
     }
 
     #[inline]
     fn fold_page_selector_pseudos(
         &mut self,
         node: Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PageSelectorPseudo> {
-        <V as FoldAstPath>::fold_page_selector_pseudos(&mut **self, node, __ast_path)
+        <V as Fold>::fold_page_selector_pseudos(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selector_type(
-        &mut self,
-        node: PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorType {
-        <V as FoldAstPath>::fold_page_selector_type(&mut **self, node, __ast_path)
+    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
+        <V as Fold>::fold_page_selector_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_page_selectors(
-        &mut self,
-        node: Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PageSelector> {
-        <V as FoldAstPath>::fold_page_selectors(&mut **self, node, __ast_path)
+    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
+        <V as Fold>::fold_page_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
-        <V as FoldAstPath>::fold_percentage(&mut **self, node, __ast_path)
+    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
+        <V as Fold>::fold_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(
-        &mut self,
-        node: PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PseudoClassSelector {
-        <V as FoldAstPath>::fold_pseudo_class_selector(&mut **self, node, __ast_path)
+    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
+        <V as Fold>::fold_pseudo_class_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_class_selector_children(
         &mut self,
         node: PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoClassSelectorChildren {
-        <V as FoldAstPath>::fold_pseudo_class_selector_children(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_class_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_class_selector_childrens(
         &mut self,
         node: Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoClassSelectorChildren> {
-        <V as FoldAstPath>::fold_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_class_selector_childrens(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_element_selector(
         &mut self,
         node: PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelector {
-        <V as FoldAstPath>::fold_pseudo_element_selector(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_element_selector(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_element_selector_children(
         &mut self,
         node: PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelectorChildren {
-        <V as FoldAstPath>::fold_pseudo_element_selector_children(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_element_selector_children(&mut **self, node)
     }
 
     #[inline]
     fn fold_pseudo_element_selector_childrens(
         &mut self,
         node: Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoElementSelectorChildren> {
-        <V as FoldAstPath>::fold_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
+        <V as Fold>::fold_pseudo_element_selector_childrens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_qualified_rule(
-        &mut self,
-        node: QualifiedRule,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRule {
-        <V as FoldAstPath>::fold_qualified_rule(&mut **self, node, __ast_path)
+    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
+        <V as Fold>::fold_qualified_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_qualified_rule_prelude(
-        &mut self,
-        node: QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRulePrelude {
-        <V as FoldAstPath>::fold_qualified_rule_prelude(&mut **self, node, __ast_path)
+    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
+        <V as Fold>::fold_qualified_rule_prelude(&mut **self, node)
     }
 
     #[inline]
-    fn fold_query_in_parens(
-        &mut self,
-        node: QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> QueryInParens {
-        <V as FoldAstPath>::fold_query_in_parens(&mut **self, node, __ast_path)
+    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
+        <V as Fold>::fold_query_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
-        <V as FoldAstPath>::fold_ratio(&mut **self, node, __ast_path)
+    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
+        <V as Fold>::fold_ratio(&mut **self, node)
     }
 
     #[inline]
-    fn fold_relative_selector(
-        &mut self,
-        node: RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelector {
-        <V as FoldAstPath>::fold_relative_selector(&mut **self, node, __ast_path)
+    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
+        <V as Fold>::fold_relative_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_relative_selector_list(
-        &mut self,
-        node: RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelectorList {
-        <V as FoldAstPath>::fold_relative_selector_list(&mut **self, node, __ast_path)
+    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
+        <V as Fold>::fold_relative_selector_list(&mut **self, node)
     }
 
     #[inline]
-    fn fold_relative_selectors(
-        &mut self,
-        node: Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<RelativeSelector> {
-        <V as FoldAstPath>::fold_relative_selectors(&mut **self, node, __ast_path)
+    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
+        <V as Fold>::fold_relative_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
-        <V as FoldAstPath>::fold_resolution(&mut **self, node, __ast_path)
+    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
+        <V as Fold>::fold_resolution(&mut **self, node)
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
-        <V as FoldAstPath>::fold_rule(&mut **self, node, __ast_path)
+    fn fold_rule(&mut self, node: Rule) -> Rule {
+        <V as Fold>::fold_rule(&mut **self, node)
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
-        <V as FoldAstPath>::fold_rules(&mut **self, node, __ast_path)
+    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
+        <V as Fold>::fold_rules(&mut **self, node)
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
-        <V as FoldAstPath>::fold_scope_range(&mut **self, node, __ast_path)
+    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
+        <V as Fold>::fold_scope_range(&mut **self, node)
     }
 
     #[inline]
-    fn fold_selector_list(
-        &mut self,
-        node: SelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> SelectorList {
-        <V as FoldAstPath>::fold_selector_list(&mut **self, node, __ast_path)
+    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
+        <V as Fold>::fold_selector_list(&mut **self, node)
     }
 
     #[inline]
     fn fold_sequence_of_custom_idents(
         &mut self,
         node: SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
     ) -> SequenceOfCustomIdents {
-        <V as FoldAstPath>::fold_sequence_of_custom_idents(&mut **self, node, __ast_path)
+        <V as Fold>::fold_sequence_of_custom_idents(&mut **self, node)
     }
 
     #[inline]
-    fn fold_simple_block(
-        &mut self,
-        node: SimpleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleBlock {
-        <V as FoldAstPath>::fold_simple_block(&mut **self, node, __ast_path)
+    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
+        <V as Fold>::fold_simple_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature(
-        &mut self,
-        node: SizeFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeature {
-        <V as FoldAstPath>::fold_size_feature(&mut **self, node, __ast_path)
+    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
+        <V as Fold>::fold_size_feature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_boolean(
-        &mut self,
-        node: SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureBoolean {
-        <V as FoldAstPath>::fold_size_feature_boolean(&mut **self, node, __ast_path)
+    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
+        <V as Fold>::fold_size_feature_boolean(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_name(
-        &mut self,
-        node: SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureName {
-        <V as FoldAstPath>::fold_size_feature_name(&mut **self, node, __ast_path)
+    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
+        <V as Fold>::fold_size_feature_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_plain(
-        &mut self,
-        node: SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeaturePlain {
-        <V as FoldAstPath>::fold_size_feature_plain(&mut **self, node, __ast_path)
+    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
+        <V as Fold>::fold_size_feature_plain(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_range(
-        &mut self,
-        node: SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureRange {
-        <V as FoldAstPath>::fold_size_feature_range(&mut **self, node, __ast_path)
+    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
+        <V as Fold>::fold_size_feature_range(&mut **self, node)
     }
 
     #[inline]
     fn fold_size_feature_range_comparison(
         &mut self,
         node: SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeComparison {
-        <V as FoldAstPath>::fold_size_feature_range_comparison(&mut **self, node, __ast_path)
+        <V as Fold>::fold_size_feature_range_comparison(&mut **self, node)
     }
 
     #[inline]
     fn fold_size_feature_range_interval(
         &mut self,
         node: SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeInterval {
-        <V as FoldAstPath>::fold_size_feature_range_interval(&mut **self, node, __ast_path)
+        <V as Fold>::fold_size_feature_range_interval(&mut **self, node)
     }
 
     #[inline]
-    fn fold_size_feature_value(
-        &mut self,
-        node: SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureValue {
-        <V as FoldAstPath>::fold_size_feature_value(&mut **self, node, __ast_path)
+    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
+        <V as Fold>::fold_size_feature_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
-        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+        <V as Fold>::fold_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
-        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
+    fn fold_str(&mut self, node: Str) -> Str {
+        <V as Fold>::fold_str(&mut **self, node)
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
-        <V as FoldAstPath>::fold_style_block(&mut **self, node, __ast_path)
+    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
+        <V as Fold>::fold_style_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
-        <V as FoldAstPath>::fold_stylesheet(&mut **self, node, __ast_path)
+    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
+        <V as Fold>::fold_stylesheet(&mut **self, node)
     }
 
     #[inline]
-    fn fold_subclass_selector(
-        &mut self,
-        node: SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> SubclassSelector {
-        <V as FoldAstPath>::fold_subclass_selector(&mut **self, node, __ast_path)
+    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
+        <V as Fold>::fold_subclass_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_subclass_selectors(
-        &mut self,
-        node: Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SubclassSelector> {
-        <V as FoldAstPath>::fold_subclass_selectors(&mut **self, node, __ast_path)
+    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
+        <V as Fold>::fold_subclass_selectors(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_and(
-        &mut self,
-        node: SupportsAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsAnd {
-        <V as FoldAstPath>::fold_supports_and(&mut **self, node, __ast_path)
+    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
+        <V as Fold>::fold_supports_and(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_condition(
-        &mut self,
-        node: SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsCondition {
-        <V as FoldAstPath>::fold_supports_condition(&mut **self, node, __ast_path)
+    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
+        <V as Fold>::fold_supports_condition(&mut **self, node)
     }
 
     #[inline]
     fn fold_supports_condition_type(
         &mut self,
         node: SupportsConditionType,
-        __ast_path: &mut AstKindPath,
     ) -> SupportsConditionType {
-        <V as FoldAstPath>::fold_supports_condition_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_supports_condition_type(&mut **self, node)
     }
 
     #[inline]
     fn fold_supports_condition_types(
         &mut self,
         node: Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<SupportsConditionType> {
-        <V as FoldAstPath>::fold_supports_condition_types(&mut **self, node, __ast_path)
+        <V as Fold>::fold_supports_condition_types(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_feature(
-        &mut self,
-        node: SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsFeature {
-        <V as FoldAstPath>::fold_supports_feature(&mut **self, node, __ast_path)
+    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
+        <V as Fold>::fold_supports_feature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_in_parens(
-        &mut self,
-        node: SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsInParens {
-        <V as FoldAstPath>::fold_supports_in_parens(&mut **self, node, __ast_path)
+    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
+        <V as Fold>::fold_supports_in_parens(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_not(
-        &mut self,
-        node: SupportsNot,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsNot {
-        <V as FoldAstPath>::fold_supports_not(&mut **self, node, __ast_path)
+    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
+        <V as Fold>::fold_supports_not(&mut **self, node)
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
-        <V as FoldAstPath>::fold_supports_or(&mut **self, node, __ast_path)
+    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
+        <V as Fold>::fold_supports_or(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tag_name_selector(
-        &mut self,
-        node: TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TagNameSelector {
-        <V as FoldAstPath>::fold_tag_name_selector(&mut **self, node, __ast_path)
+    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
+        <V as Fold>::fold_tag_name_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
-        <V as FoldAstPath>::fold_time(&mut **self, node, __ast_path)
+    fn fold_time(&mut self, node: Time) -> Time {
+        <V as Fold>::fold_time(&mut **self, node)
     }
 
     #[inline]
-    fn fold_time_percentage(
-        &mut self,
-        node: TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> TimePercentage {
-        <V as FoldAstPath>::fold_time_percentage(&mut **self, node, __ast_path)
+    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
+        <V as Fold>::fold_time_percentage(&mut **self, node)
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
-        <V as FoldAstPath>::fold_token(&mut **self, node, __ast_path)
+    fn fold_token(&mut self, node: Token) -> Token {
+        <V as Fold>::fold_token(&mut **self, node)
     }
 
     #[inline]
-    fn fold_token_and_span(
-        &mut self,
-        node: TokenAndSpan,
-        __ast_path: &mut AstKindPath,
-    ) -> TokenAndSpan {
-        <V as FoldAstPath>::fold_token_and_span(&mut **self, node, __ast_path)
+    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
+        <V as Fold>::fold_token_and_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_type_selector(
-        &mut self,
-        node: TypeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TypeSelector {
-        <V as FoldAstPath>::fold_type_selector(&mut **self, node, __ast_path)
+    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
+        <V as Fold>::fold_type_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unicode_range(
-        &mut self,
-        node: UnicodeRange,
-        __ast_path: &mut AstKindPath,
-    ) -> UnicodeRange {
-        <V as FoldAstPath>::fold_unicode_range(&mut **self, node, __ast_path)
+    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
+        <V as Fold>::fold_unicode_range(&mut **self, node)
     }
 
     #[inline]
-    fn fold_universal_selector(
-        &mut self,
-        node: UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> UniversalSelector {
-        <V as FoldAstPath>::fold_universal_selector(&mut **self, node, __ast_path)
+    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
+        <V as Fold>::fold_universal_selector(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unknown_dimension(
-        &mut self,
-        node: UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) -> UnknownDimension {
-        <V as FoldAstPath>::fold_unknown_dimension(&mut **self, node, __ast_path)
+    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
+        <V as Fold>::fold_unknown_dimension(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
-        <V as FoldAstPath>::fold_url(&mut **self, node, __ast_path)
+    fn fold_url(&mut self, node: Url) -> Url {
+        <V as Fold>::fold_url(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_key_value(
-        &mut self,
-        node: UrlKeyValue,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlKeyValue {
-        <V as FoldAstPath>::fold_url_key_value(&mut **self, node, __ast_path)
+    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
+        <V as Fold>::fold_url_key_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_modifier(
-        &mut self,
-        node: UrlModifier,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlModifier {
-        <V as FoldAstPath>::fold_url_modifier(&mut **self, node, __ast_path)
+    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
+        <V as Fold>::fold_url_modifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_modifiers(
-        &mut self,
-        node: Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<UrlModifier> {
-        <V as FoldAstPath>::fold_url_modifiers(&mut **self, node, __ast_path)
+    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
+        <V as Fold>::fold_url_modifiers(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
-        <V as FoldAstPath>::fold_url_value(&mut **self, node, __ast_path)
+    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
+        <V as Fold>::fold_url_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_url_value_raw(
-        &mut self,
-        node: UrlValueRaw,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlValueRaw {
-        <V as FoldAstPath>::fold_url_value_raw(&mut **self, node, __ast_path)
+    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
+        <V as Fold>::fold_url_value_raw(&mut **self, node)
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
-        <V as FoldAstPath>::fold_wq_name(&mut **self, node, __ast_path)
+    fn fold_wq_name(&mut self, node: WqName) -> WqName {
+        <V as Fold>::fold_wq_name(&mut **self, node)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<A, B> FoldAstPath for ::swc_visit::Either<A, B>
+impl<A, B> Fold for ::swc_visit::Either<A, B>
 where
-    A: FoldAstPath,
-    B: FoldAstPath,
+    A: Fold,
+    B: Fold,
 {
     #[inline]
-    fn fold_absolute_color_base(
-        &mut self,
-        node: AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) -> AbsoluteColorBase {
+    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_absolute_color_base(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_absolute_color_base(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_absolute_color_base(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_absolute_color_base(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
+    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_alpha_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_alpha_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_alpha_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_alpha_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
+    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_an_plus_b(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_an_plus_b(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_an_plus_b(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_an_plus_b(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(
-        &mut self,
-        node: AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) -> AnPlusBNotation {
+    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_an_plus_b_notation(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_an_plus_b_notation(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_an_plus_b_notation(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_an_plus_b_notation(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
+    fn fold_angle(&mut self, node: Angle) -> Angle {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_angle(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_angle(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_angle(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_angle(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_angle_percentage(
-        &mut self,
-        node: AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> AnglePercentage {
+    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_angle_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_angle_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_angle_percentage(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_angle_percentage(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_any_namespace(
-        &mut self,
-        node: AnyNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> AnyNamespace {
+    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_any_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_any_namespace(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_any_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_any_namespace(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
+    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_at_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_at_rule(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_at_rule(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_at_rule(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
+    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_at_rule_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_at_rule_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_at_rule_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_at_rule_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_at_rule_prelude(
-        &mut self,
-        node: AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> AtRulePrelude {
+    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_at_rule_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_at_rule_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_at_rule_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_at_rule_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_atom(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_attribute_selector(
-        &mut self,
-        node: AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> AttributeSelector {
+    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_attribute_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_attribute_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_attribute_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_attribute_selector(visitor, node),
         }
     }
 
@@ -93621,14 +76648,13 @@ where
     fn fold_attribute_selector_matcher(
         &mut self,
         node: AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcher {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_attribute_selector_matcher(visitor, node, __ast_path)
+                Fold::fold_attribute_selector_matcher(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_attribute_selector_matcher(visitor, node, __ast_path)
+                Fold::fold_attribute_selector_matcher(visitor, node)
             }
         }
     }
@@ -93637,14 +76663,13 @@ where
     fn fold_attribute_selector_matcher_value(
         &mut self,
         node: AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcherValue {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_attribute_selector_matcher_value(visitor, node, __ast_path)
+                Fold::fold_attribute_selector_matcher_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_attribute_selector_matcher_value(visitor, node, __ast_path)
+                Fold::fold_attribute_selector_matcher_value(visitor, node)
             }
         }
     }
@@ -93653,14 +76678,13 @@ where
     fn fold_attribute_selector_modifier(
         &mut self,
         node: AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorModifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_attribute_selector_modifier(visitor, node, __ast_path)
+                Fold::fold_attribute_selector_modifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_attribute_selector_modifier(visitor, node, __ast_path)
+                Fold::fold_attribute_selector_modifier(visitor, node)
             }
         }
     }
@@ -93669,73 +76693,42 @@ where
     fn fold_attribute_selector_value(
         &mut self,
         node: AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_attribute_selector_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_attribute_selector_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_attribute_selector_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_attribute_selector_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
+    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_bin_op(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_bin_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_bin_op(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_bin_op(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_calc_operator(
-        &mut self,
-        node: CalcOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperator {
+    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_operator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_operator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_operator(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_calc_operator_type(
-        &mut self,
-        node: CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperatorType {
+    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_operator_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_operator_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_operator_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_operator_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_calc_product(
-        &mut self,
-        node: CalcProduct,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcProduct {
+    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_product(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_product(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_product(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_product(visitor, node),
         }
     }
 
@@ -93743,15 +76736,10 @@ where
     fn fold_calc_product_or_operator(
         &mut self,
         node: CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
     ) -> CalcProductOrOperator {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_product_or_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_product_or_operator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_product_or_operator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_product_or_operator(visitor, node),
         }
     }
 
@@ -93759,55 +76747,36 @@ where
     fn fold_calc_product_or_operators(
         &mut self,
         node: Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcProductOrOperator> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_product_or_operators(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_product_or_operators(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_product_or_operators(visitor, node, __ast_path)
+                Fold::fold_calc_product_or_operators(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
+    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_sum(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_sum(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_sum(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_sum(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
+    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(
-        &mut self,
-        node: CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcValueOrOperator {
+    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_value_or_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_value_or_operator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_value_or_operator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_value_or_operator(visitor, node),
         }
     }
 
@@ -93815,115 +76784,66 @@ where
     fn fold_calc_value_or_operators(
         &mut self,
         node: Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcValueOrOperator> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_calc_value_or_operators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_calc_value_or_operators(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_calc_value_or_operators(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_calc_value_or_operators(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class_selector(
-        &mut self,
-        node: ClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassSelector {
+    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_class_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_class_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_class_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_cmyk_component(
-        &mut self,
-        node: CmykComponent,
-        __ast_path: &mut AstKindPath,
-    ) -> CmykComponent {
+    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_cmyk_component(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_cmyk_component(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_cmyk_component(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_cmyk_component(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
+    fn fold_color(&mut self, node: Color) -> Color {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_color(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_color(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_color(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_color(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_color_profile_name(
-        &mut self,
-        node: ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) -> ColorProfileName {
+    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_color_profile_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_color_profile_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_color_profile_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_color_profile_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
+    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_combinator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_combinator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_combinator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_combinator(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_combinator_value(
-        &mut self,
-        node: CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) -> CombinatorValue {
+    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_combinator_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_combinator_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_combinator_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_combinator_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_complex_selector(
-        &mut self,
-        node: ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ComplexSelector {
+    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_complex_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_complex_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_complex_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_complex_selector(visitor, node),
         }
     }
 
@@ -93931,14 +76851,11 @@ where
     fn fold_complex_selector_children(
         &mut self,
         node: ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> ComplexSelectorChildren {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_complex_selector_children(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_complex_selector_children(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_complex_selector_children(visitor, node, __ast_path)
+                Fold::fold_complex_selector_children(visitor, node)
             }
         }
     }
@@ -93947,223 +76864,118 @@ where
     fn fold_complex_selector_childrens(
         &mut self,
         node: Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ComplexSelectorChildren> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_complex_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_complex_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_complex_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_complex_selector_childrens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_complex_selectors(
-        &mut self,
-        node: Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComplexSelector> {
+    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_complex_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_complex_selectors(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_complex_selectors(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_complex_selectors(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_component_value(
-        &mut self,
-        node: ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) -> ComponentValue {
+    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_component_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_component_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_component_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_component_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_component_values(
-        &mut self,
-        node: Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComponentValue> {
+    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_component_values(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_component_values(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_component_values(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_component_values(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_compound_selector(
-        &mut self,
-        node: CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelector {
+    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_compound_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_compound_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_compound_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_compound_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_compound_selector_list(
-        &mut self,
-        node: CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelectorList {
+    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_compound_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_compound_selector_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_compound_selector_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_compound_selector_list(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_compound_selectors(
-        &mut self,
-        node: Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CompoundSelector> {
+    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_compound_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_compound_selectors(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_compound_selectors(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_compound_selectors(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_container_condition(
-        &mut self,
-        node: ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerCondition {
+    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_condition(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_condition(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_condition(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_condition(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_container_name(
-        &mut self,
-        node: ContainerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerName {
+    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_container_query(
-        &mut self,
-        node: ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQuery {
+    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_query(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_query(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_query(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_container_query_and(
-        &mut self,
-        node: ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryAnd {
+    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_query_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_query_and(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_query_and(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_query_and(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_container_query_not(
-        &mut self,
-        node: ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryNot {
+    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_query_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_query_not(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_query_not(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_query_not(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_container_query_or(
-        &mut self,
-        node: ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryOr {
+    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_query_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_query_or(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_query_or(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_query_or(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_container_query_type(
-        &mut self,
-        node: ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryType {
+    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_query_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_query_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_query_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_query_type(visitor, node),
         }
     }
 
@@ -94171,79 +76983,42 @@ where
     fn fold_container_query_types(
         &mut self,
         node: Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ContainerQueryType> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_container_query_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_container_query_types(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_container_query_types(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_container_query_types(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_custom_highlight_name(
-        &mut self,
-        node: CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomHighlightName {
+    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_custom_highlight_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_custom_highlight_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_custom_highlight_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_custom_highlight_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_custom_ident(
-        &mut self,
-        node: CustomIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomIdent {
+    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_custom_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_custom_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_custom_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_custom_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_custom_idents(
-        &mut self,
-        node: Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CustomIdent> {
+    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_custom_idents(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_custom_idents(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_custom_idents(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_custom_idents(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_custom_media_query(
-        &mut self,
-        node: CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomMediaQuery {
+    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_custom_media_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_custom_media_query(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_custom_media_query(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_custom_media_query(visitor, node),
         }
     }
 
@@ -94251,163 +77026,94 @@ where
     fn fold_custom_media_query_media_type(
         &mut self,
         node: CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
     ) -> CustomMediaQueryMediaType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_custom_media_query_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_custom_media_query_media_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn fold_custom_property_name(
-        &mut self,
-        node: CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomPropertyName {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_custom_property_name(visitor, node, __ast_path)
+                Fold::fold_custom_media_query_media_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_custom_property_name(visitor, node, __ast_path)
+                Fold::fold_custom_media_query_media_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_dashed_ident(
-        &mut self,
-        node: DashedIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> DashedIdent {
+    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_dashed_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_dashed_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_custom_property_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_custom_property_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
+    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_declaration(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_declaration(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_dashed_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_dashed_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_declaration_name(
-        &mut self,
-        node: DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationName {
+    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_declaration_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_declaration_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_declaration(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_declaration(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(
-        &mut self,
-        node: DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationOrAtRule {
+    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_declaration_or_at_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_declaration_or_at_rule(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_declaration_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_declaration_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
+    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_delimiter(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_delimiter(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_declaration_or_at_rule(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_declaration_or_at_rule(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_delimiter_value(
-        &mut self,
-        node: DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) -> DelimiterValue {
+    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_delimiter_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_delimiter_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_delimiter(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_delimiter(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
+    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_dimension(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_dimension(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_delimiter_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_delimiter_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_dimension_token(
-        &mut self,
-        node: DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) -> DimensionToken {
+    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_dimension_token(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_dimension_token(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_dimension(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_dimension(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_document_prelude(
-        &mut self,
-        node: DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> DocumentPrelude {
+    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_document_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_document_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_dimension_token(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_dimension_token(visitor, node),
+        }
+    }
+
+    #[inline]
+    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
+        match self {
+            swc_visit::Either::Left(visitor) => Fold::fold_document_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_document_prelude(visitor, node),
         }
     }
 
@@ -94415,14 +77121,13 @@ where
     fn fold_document_prelude_matching_function(
         &mut self,
         node: DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) -> DocumentPreludeMatchingFunction {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_document_prelude_matching_function(visitor, node, __ast_path)
+                Fold::fold_document_prelude_matching_function(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_document_prelude_matching_function(visitor, node, __ast_path)
+                Fold::fold_document_prelude_matching_function(visitor, node)
             }
         }
     }
@@ -94431,67 +77136,46 @@ where
     fn fold_document_prelude_matching_functions(
         &mut self,
         node: Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<DocumentPreludeMatchingFunction> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_document_prelude_matching_functions(visitor, node, __ast_path)
+                Fold::fold_document_prelude_matching_functions(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_document_prelude_matching_functions(visitor, node, __ast_path)
+                Fold::fold_document_prelude_matching_functions(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_extension_name(
-        &mut self,
-        node: ExtensionName,
-        __ast_path: &mut AstKindPath,
-    ) -> ExtensionName {
+    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_extension_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_extension_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_extension_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_extension_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
+    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_family_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_family_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_family_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_family_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_family_names(
-        &mut self,
-        node: Vec<FamilyName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<FamilyName> {
+    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_family_names(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_family_names(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_family_names(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_family_names(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
+    fn fold_flex(&mut self, node: Flex) -> Flex {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_flex(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_flex(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_flex(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_flex(visitor, node),
         }
     }
 
@@ -94499,14 +77183,13 @@ where
     fn fold_font_feature_values_prelude(
         &mut self,
         node: FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
     ) -> FontFeatureValuesPrelude {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_font_feature_values_prelude(visitor, node, __ast_path)
+                Fold::fold_font_feature_values_prelude(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_font_feature_values_prelude(visitor, node, __ast_path)
+                Fold::fold_font_feature_values_prelude(visitor, node)
             }
         }
     }
@@ -94515,14 +77198,13 @@ where
     fn fold_forgiving_complex_selector(
         &mut self,
         node: ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingComplexSelector {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_forgiving_complex_selector(visitor, node, __ast_path)
+                Fold::fold_forgiving_complex_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_forgiving_complex_selector(visitor, node, __ast_path)
+                Fold::fold_forgiving_complex_selector(visitor, node)
             }
         }
     }
@@ -94531,14 +77213,13 @@ where
     fn fold_forgiving_complex_selectors(
         &mut self,
         node: Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingComplexSelector> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_forgiving_complex_selectors(visitor, node, __ast_path)
+                Fold::fold_forgiving_complex_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_forgiving_complex_selectors(visitor, node, __ast_path)
+                Fold::fold_forgiving_complex_selectors(visitor, node)
             }
         }
     }
@@ -94547,14 +77228,13 @@ where
     fn fold_forgiving_relative_selector(
         &mut self,
         node: ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelector {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_forgiving_relative_selector(visitor, node, __ast_path)
+                Fold::fold_forgiving_relative_selector(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_forgiving_relative_selector(visitor, node, __ast_path)
+                Fold::fold_forgiving_relative_selector(visitor, node)
             }
         }
     }
@@ -94563,14 +77243,13 @@ where
     fn fold_forgiving_relative_selector_list(
         &mut self,
         node: ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelectorList {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_forgiving_relative_selector_list(visitor, node, __ast_path)
+                Fold::fold_forgiving_relative_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_forgiving_relative_selector_list(visitor, node, __ast_path)
+                Fold::fold_forgiving_relative_selector_list(visitor, node)
             }
         }
     }
@@ -94579,14 +77258,13 @@ where
     fn fold_forgiving_relative_selectors(
         &mut self,
         node: Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingRelativeSelector> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_forgiving_relative_selectors(visitor, node, __ast_path)
+                Fold::fold_forgiving_relative_selectors(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_forgiving_relative_selectors(visitor, node, __ast_path)
+                Fold::fold_forgiving_relative_selectors(visitor, node)
             }
         }
     }
@@ -94595,289 +77273,170 @@ where
     fn fold_forgiving_selector_list(
         &mut self,
         node: ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingSelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_forgiving_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_forgiving_selector_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_forgiving_selector_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_forgiving_selector_list(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
+    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_frequency(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_frequency(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_frequency(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_frequency(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_frequency_percentage(
-        &mut self,
-        node: FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> FrequencyPercentage {
+    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_frequency_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_frequency_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_frequency_percentage(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_frequency_percentage(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+    fn fold_function(&mut self, node: Function) -> Function {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_function(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_function(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_function(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_function_name(
-        &mut self,
-        node: FunctionName,
-        __ast_path: &mut AstKindPath,
-    ) -> FunctionName {
+    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_function_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_function_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_function_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_function_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_general_enclosed(
-        &mut self,
-        node: GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) -> GeneralEnclosed {
+    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_general_enclosed(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_general_enclosed(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_general_enclosed(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_general_enclosed(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
+    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_hex_color(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_hex_color(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_hex_color(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_hex_color(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
+    fn fold_hue(&mut self, node: Hue) -> Hue {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_hue(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_hue(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_hue(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_hue(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
+    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_id_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_id_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_id_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_id_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+    fn fold_ident(&mut self, node: Ident) -> Ident {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
+    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_idents(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_idents(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_idents(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_idents(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_conditions(
-        &mut self,
-        node: ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportConditions {
+    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_conditions(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_conditions(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_conditions(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_conditions(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
+    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_href(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_href(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_href(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_href(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_layer_name(
-        &mut self,
-        node: ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportLayerName {
+    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_layer_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_layer_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_layer_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_layer_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_prelude(
-        &mut self,
-        node: ImportPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPrelude {
+    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_important_flag(
-        &mut self,
-        node: ImportantFlag,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportantFlag {
+    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_important_flag(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_important_flag(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_important_flag(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_important_flag(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
+    fn fold_integer(&mut self, node: Integer) -> Integer {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_integer(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_integer(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_integer(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_integer(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_keyframe_block(
-        &mut self,
-        node: KeyframeBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeBlock {
+    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_keyframe_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_keyframe_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_keyframe_block(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_keyframe_block(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_keyframe_selector(
-        &mut self,
-        node: KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeSelector {
+    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_keyframe_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_keyframe_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_keyframe_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_keyframe_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_keyframe_selectors(
-        &mut self,
-        node: Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<KeyframeSelector> {
+    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_keyframe_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_keyframe_selectors(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_keyframe_selectors(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_keyframe_selectors(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_keyframes_name(
-        &mut self,
-        node: KeyframesName,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframesName {
+    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_keyframes_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_keyframes_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_keyframes_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_keyframes_name(visitor, node),
         }
     }
 
@@ -94885,14 +77444,11 @@ where
     fn fold_keyframes_pseudo_function(
         &mut self,
         node: KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoFunction {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_keyframes_pseudo_function(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_keyframes_pseudo_function(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_keyframes_pseudo_function(visitor, node, __ast_path)
+                Fold::fold_keyframes_pseudo_function(visitor, node)
             }
         }
     }
@@ -94901,101 +77457,58 @@ where
     fn fold_keyframes_pseudo_prefix(
         &mut self,
         node: KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoPrefix {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_keyframes_pseudo_prefix(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_keyframes_pseudo_prefix(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_keyframes_pseudo_prefix(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_keyframes_pseudo_prefix(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
+    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_layer_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_layer_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_layer_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_layer_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_layer_name_list(
-        &mut self,
-        node: LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerNameList {
+    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_layer_name_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_layer_name_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_layer_name_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_layer_name_list(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_layer_names(
-        &mut self,
-        node: Vec<LayerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<LayerName> {
+    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_layer_names(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_layer_names(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_layer_names(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_layer_names(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_layer_prelude(
-        &mut self,
-        node: LayerPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerPrelude {
+    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_layer_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_layer_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_layer_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_layer_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
+    fn fold_length(&mut self, node: Length) -> Length {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_length(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_length(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_length(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_length(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_length_percentage(
-        &mut self,
-        node: LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> LengthPercentage {
+    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_length_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_length_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_length_percentage(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_length_percentage(visitor, node),
         }
     }
 
@@ -95003,43 +77516,26 @@ where
     fn fold_list_of_component_values(
         &mut self,
         node: ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
     ) -> ListOfComponentValues {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_list_of_component_values(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_list_of_component_values(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_list_of_component_values(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_list_of_component_values(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
+    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_and(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_and(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_and(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_condition(
-        &mut self,
-        node: MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaCondition {
+    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_condition(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_condition(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_condition(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_condition(visitor, node),
         }
     }
 
@@ -95047,15 +77543,10 @@ where
     fn fold_media_condition_all_type(
         &mut self,
         node: MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionAllType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_condition_all_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_condition_all_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_condition_all_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_condition_all_type(visitor, node),
         }
     }
 
@@ -95063,31 +77554,20 @@ where
     fn fold_media_condition_all_types(
         &mut self,
         node: Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionAllType> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_condition_all_types(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_condition_all_types(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_condition_all_types(visitor, node, __ast_path)
+                Fold::fold_media_condition_all_types(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_media_condition_type(
-        &mut self,
-        node: MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaConditionType {
+    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_condition_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_condition_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_condition_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_condition_type(visitor, node),
         }
     }
 
@@ -95095,14 +77575,13 @@ where
     fn fold_media_condition_without_or(
         &mut self,
         node: MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOr {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_condition_without_or(visitor, node, __ast_path)
+                Fold::fold_media_condition_without_or(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_condition_without_or(visitor, node, __ast_path)
+                Fold::fold_media_condition_without_or(visitor, node)
             }
         }
     }
@@ -95111,14 +77590,13 @@ where
     fn fold_media_condition_without_or_type(
         &mut self,
         node: MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOrType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_condition_without_or_type(visitor, node, __ast_path)
+                Fold::fold_media_condition_without_or_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_condition_without_or_type(visitor, node, __ast_path)
+                Fold::fold_media_condition_without_or_type(visitor, node)
             }
         }
     }
@@ -95127,95 +77605,54 @@ where
     fn fold_media_condition_without_or_types(
         &mut self,
         node: Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionWithoutOrType> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_condition_without_or_types(visitor, node, __ast_path)
+                Fold::fold_media_condition_without_or_types(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_condition_without_or_types(visitor, node, __ast_path)
+                Fold::fold_media_condition_without_or_types(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_media_feature(
-        &mut self,
-        node: MediaFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeature {
+    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_feature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_feature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_feature_boolean(
-        &mut self,
-        node: MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureBoolean {
+    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature_boolean(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature_boolean(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_boolean(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_boolean(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_feature_name(
-        &mut self,
-        node: MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureName {
+    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_feature_plain(
-        &mut self,
-        node: MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeaturePlain {
+    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature_plain(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature_plain(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_plain(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_plain(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_feature_range(
-        &mut self,
-        node: MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureRange {
+    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature_range(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_range(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_range(visitor, node),
         }
     }
 
@@ -95223,14 +77660,13 @@ where
     fn fold_media_feature_range_comparison(
         &mut self,
         node: MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeComparison {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature_range_comparison(visitor, node, __ast_path)
+                Fold::fold_media_feature_range_comparison(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature_range_comparison(visitor, node, __ast_path)
+                Fold::fold_media_feature_range_comparison(visitor, node)
             }
         }
     }
@@ -95239,241 +77675,142 @@ where
     fn fold_media_feature_range_interval(
         &mut self,
         node: MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeInterval {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature_range_interval(visitor, node, __ast_path)
+                Fold::fold_media_feature_range_interval(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature_range_interval(visitor, node, __ast_path)
+                Fold::fold_media_feature_range_interval(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_media_feature_value(
-        &mut self,
-        node: MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureValue {
+    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_feature_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_feature_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_feature_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_feature_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_in_parens(
-        &mut self,
-        node: MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaInParens {
+    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_in_parens(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_in_parens(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_in_parens(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
+    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_not(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_not(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_not(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
+    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_or(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_or(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_or(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
+    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_query(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_query(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_query(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_query_list(
-        &mut self,
-        node: MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaQueryList {
+    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_query_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_query_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_query_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_query_list(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_querys(
-        &mut self,
-        node: Vec<MediaQuery>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<MediaQuery> {
+    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_querys(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_querys(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_querys(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_querys(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
+    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_media_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_media_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_media_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_named_namespace(
-        &mut self,
-        node: NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedNamespace {
+    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_named_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_named_namespace(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_named_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_named_namespace(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
+    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_namespace(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_namespace(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_namespace_prefix(
-        &mut self,
-        node: NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrefix {
+    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_namespace_prefix(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_namespace_prefix(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_namespace_prefix(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_namespace_prefix(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude(
-        &mut self,
-        node: NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrelude {
+    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_namespace_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_namespace_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_namespace_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_namespace_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(
-        &mut self,
-        node: NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePreludeUri {
+    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_namespace_prelude_uri(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_namespace_prelude_uri(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_namespace_prelude_uri(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_namespace_prelude_uri(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_nesting_selector(
-        &mut self,
-        node: NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> NestingSelector {
+    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_nesting_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_nesting_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_nesting_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_nesting_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+    fn fold_number(&mut self, node: Number) -> Number {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_number(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_number(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_number(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_number(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
+    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_number_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_number_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_number_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_number_type(visitor, node),
         }
     }
 
@@ -95481,31 +77818,18 @@ where
     fn fold_opt_at_rule_prelude(
         &mut self,
         node: Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<AtRulePrelude>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_at_rule_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_at_rule_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_at_rule_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_at_rule_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_atom(visitor, node),
         }
     }
 
@@ -95513,14 +77837,13 @@ where
     fn fold_opt_attribute_selector_matcher(
         &mut self,
         node: Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorMatcher> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_attribute_selector_matcher(visitor, node, __ast_path)
+                Fold::fold_opt_attribute_selector_matcher(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_attribute_selector_matcher(visitor, node, __ast_path)
+                Fold::fold_opt_attribute_selector_matcher(visitor, node)
             }
         }
     }
@@ -95529,14 +77852,13 @@ where
     fn fold_opt_attribute_selector_modifier(
         &mut self,
         node: Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorModifier> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_attribute_selector_modifier(visitor, node, __ast_path)
+                Fold::fold_opt_attribute_selector_modifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_attribute_selector_modifier(visitor, node, __ast_path)
+                Fold::fold_opt_attribute_selector_modifier(visitor, node)
             }
         }
     }
@@ -95545,47 +77867,30 @@ where
     fn fold_opt_attribute_selector_value(
         &mut self,
         node: Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorValue> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_attribute_selector_value(visitor, node, __ast_path)
+                Fold::fold_opt_attribute_selector_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_attribute_selector_value(visitor, node, __ast_path)
+                Fold::fold_opt_attribute_selector_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_combinator(
-        &mut self,
-        node: Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Combinator> {
+    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_combinator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_combinator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_combinator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_combinator(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_container_name(
-        &mut self,
-        node: Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ContainerName> {
+    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_container_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_container_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_container_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_container_name(visitor, node),
         }
     }
 
@@ -95593,47 +77898,30 @@ where
     fn fold_opt_forgiving_selector_list(
         &mut self,
         node: Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ForgivingSelectorList> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_forgiving_selector_list(visitor, node, __ast_path)
+                Fold::fold_opt_forgiving_selector_list(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_forgiving_selector_list(visitor, node, __ast_path)
+                Fold::fold_opt_forgiving_selector_list(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_function(
-        &mut self,
-        node: Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Function>> {
+    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_function(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_function(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_function(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_ident(visitor, node),
         }
     }
 
@@ -95641,15 +77929,10 @@ where
     fn fold_opt_import_conditions(
         &mut self,
         node: Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportConditions>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_import_conditions(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_import_conditions(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_import_conditions(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_import_conditions(visitor, node),
         }
     }
 
@@ -95657,31 +77940,18 @@ where
     fn fold_opt_import_layer_name(
         &mut self,
         node: Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportLayerName>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_import_layer_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_import_layer_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_import_layer_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_import_layer_name(visitor, node),
         }
     }
 
-    #[inline]
-    fn fold_opt_important_flag(
-        &mut self,
-        node: Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ImportantFlag> {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_important_flag(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_important_flag(visitor, node, __ast_path)
-            }
+    #[inline]
+    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
+        match self {
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_important_flag(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_important_flag(visitor, node),
         }
     }
 
@@ -95689,15 +77959,10 @@ where
     fn fold_opt_media_condition_type(
         &mut self,
         node: Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaConditionType>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_media_condition_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_media_condition_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_media_condition_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_media_condition_type(visitor, node),
         }
     }
 
@@ -95705,47 +77970,26 @@ where
     fn fold_opt_media_query_list(
         &mut self,
         node: Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaQueryList>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_media_query_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_media_query_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_media_query_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_media_query_list(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_media_type(
-        &mut self,
-        node: Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<MediaType> {
+    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_media_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_media_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_media_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_media_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_namespace(
-        &mut self,
-        node: Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Namespace> {
+    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_namespace(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_namespace(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_namespace(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_namespace(visitor, node),
         }
     }
 
@@ -95753,15 +77997,10 @@ where
     fn fold_opt_namespace_prefix(
         &mut self,
         node: Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NamespacePrefix> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_namespace_prefix(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_namespace_prefix(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_namespace_prefix(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_namespace_prefix(visitor, node),
         }
     }
 
@@ -95769,31 +78008,18 @@ where
     fn fold_opt_nesting_selector(
         &mut self,
         node: Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NestingSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_nesting_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_nesting_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_nesting_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_nesting_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_number(
-        &mut self,
-        node: Option<Number>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Number> {
+    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_number(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_number(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_number(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_number(visitor, node),
         }
     }
 
@@ -95801,14 +78027,11 @@ where
     fn fold_opt_page_selector_pseudos(
         &mut self,
         node: Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PageSelectorPseudo>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_page_selector_pseudos(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_page_selector_pseudos(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_page_selector_pseudos(visitor, node, __ast_path)
+                Fold::fold_opt_page_selector_pseudos(visitor, node)
             }
         }
     }
@@ -95817,15 +78040,10 @@ where
     fn fold_opt_page_selector_type(
         &mut self,
         node: Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<PageSelectorType> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_page_selector_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_page_selector_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_page_selector_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_page_selector_type(visitor, node),
         }
     }
 
@@ -95833,14 +78051,13 @@ where
     fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoClassSelectorChildren>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_opt_pseudo_class_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_opt_pseudo_class_selector_childrens(visitor, node)
             }
         }
     }
@@ -95849,31 +78066,22 @@ where
     fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoElementSelectorChildren>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_opt_pseudo_element_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_opt_pseudo_element_selector_childrens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_simple_block(
-        &mut self,
-        node: Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<SimpleBlock> {
+    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_simple_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_simple_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_simple_block(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_simple_block(visitor, node),
         }
     }
 
@@ -95881,15 +78089,10 @@ where
     fn fold_opt_type_selector(
         &mut self,
         node: Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TypeSelector>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_type_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_type_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_type_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_type_selector(visitor, node),
         }
     }
 
@@ -95897,79 +78100,42 @@ where
     fn fold_opt_url_modifiers(
         &mut self,
         node: Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<UrlModifier>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_url_modifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_url_modifiers(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_url_modifiers(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_url_modifiers(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_url_value(
-        &mut self,
-        node: Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<UrlValue>> {
+    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_url_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_url_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_url_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_url_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_page_selector(
-        &mut self,
-        node: PageSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelector {
+    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_page_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_page_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_page_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_page_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_page_selector_list(
-        &mut self,
-        node: PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorList {
+    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_page_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_page_selector_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_list(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(
-        &mut self,
-        node: PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorPseudo {
+    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_page_selector_pseudo(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_page_selector_pseudo(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_pseudo(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_pseudo(visitor, node),
         }
     }
 
@@ -95977,75 +78143,42 @@ where
     fn fold_page_selector_pseudos(
         &mut self,
         node: Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PageSelectorPseudo> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_page_selector_pseudos(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_page_selector_pseudos(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_pseudos(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_pseudos(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_page_selector_type(
-        &mut self,
-        node: PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorType {
+    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_page_selector_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_page_selector_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_page_selector_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_page_selector_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_page_selectors(
-        &mut self,
-        node: Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PageSelector> {
+    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_page_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_page_selectors(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_page_selectors(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_page_selectors(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
+    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_percentage(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_percentage(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(
-        &mut self,
-        node: PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PseudoClassSelector {
+    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_pseudo_class_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_pseudo_class_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_pseudo_class_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_pseudo_class_selector(visitor, node),
         }
     }
 
@@ -96053,14 +78186,13 @@ where
     fn fold_pseudo_class_selector_children(
         &mut self,
         node: PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoClassSelectorChildren {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_pseudo_class_selector_children(visitor, node, __ast_path)
+                Fold::fold_pseudo_class_selector_children(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_pseudo_class_selector_children(visitor, node, __ast_path)
+                Fold::fold_pseudo_class_selector_children(visitor, node)
             }
         }
     }
@@ -96069,14 +78201,13 @@ where
     fn fold_pseudo_class_selector_childrens(
         &mut self,
         node: Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoClassSelectorChildren> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_pseudo_class_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_pseudo_class_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_pseudo_class_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_pseudo_class_selector_childrens(visitor, node)
             }
         }
     }
@@ -96085,15 +78216,10 @@ where
     fn fold_pseudo_element_selector(
         &mut self,
         node: PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_pseudo_element_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_pseudo_element_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_pseudo_element_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_pseudo_element_selector(visitor, node),
         }
     }
 
@@ -96101,14 +78227,13 @@ where
     fn fold_pseudo_element_selector_children(
         &mut self,
         node: PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelectorChildren {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_pseudo_element_selector_children(visitor, node, __ast_path)
+                Fold::fold_pseudo_element_selector_children(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_pseudo_element_selector_children(visitor, node, __ast_path)
+                Fold::fold_pseudo_element_selector_children(visitor, node)
             }
         }
     }
@@ -96117,175 +78242,110 @@ where
     fn fold_pseudo_element_selector_childrens(
         &mut self,
         node: Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoElementSelectorChildren> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_pseudo_element_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_pseudo_element_selector_childrens(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_pseudo_element_selector_childrens(visitor, node, __ast_path)
+                Fold::fold_pseudo_element_selector_childrens(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_qualified_rule(
-        &mut self,
-        node: QualifiedRule,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRule {
+    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_qualified_rule(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_qualified_rule(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_qualified_rule(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_qualified_rule(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_qualified_rule_prelude(
-        &mut self,
-        node: QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRulePrelude {
+    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_qualified_rule_prelude(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_qualified_rule_prelude(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_qualified_rule_prelude(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_qualified_rule_prelude(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_query_in_parens(
-        &mut self,
-        node: QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> QueryInParens {
+    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_query_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_query_in_parens(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_query_in_parens(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_query_in_parens(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
+    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ratio(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_ratio(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_ratio(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ratio(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_relative_selector(
-        &mut self,
-        node: RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelector {
+    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_relative_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_relative_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_relative_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_relative_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_relative_selector_list(
-        &mut self,
-        node: RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelectorList {
+    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_relative_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_relative_selector_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_relative_selector_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_relative_selector_list(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_relative_selectors(
-        &mut self,
-        node: Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<RelativeSelector> {
+    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_relative_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_relative_selectors(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_relative_selectors(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_relative_selectors(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
+    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_resolution(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_resolution(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_resolution(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_resolution(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
+    fn fold_rule(&mut self, node: Rule) -> Rule {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_rule(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_rule(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_rule(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_rule(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
+    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_rules(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_rules(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_rules(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_rules(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
+    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_scope_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_scope_range(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_scope_range(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_scope_range(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_selector_list(
-        &mut self,
-        node: SelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> SelectorList {
+    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_selector_list(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_selector_list(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_selector_list(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_selector_list(visitor, node),
         }
     }
 
@@ -96293,111 +78353,60 @@ where
     fn fold_sequence_of_custom_idents(
         &mut self,
         node: SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
     ) -> SequenceOfCustomIdents {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_sequence_of_custom_idents(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_sequence_of_custom_idents(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_sequence_of_custom_idents(visitor, node, __ast_path)
+                Fold::fold_sequence_of_custom_idents(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_simple_block(
-        &mut self,
-        node: SimpleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleBlock {
+    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_simple_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_simple_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_simple_block(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_simple_block(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_size_feature(
-        &mut self,
-        node: SizeFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeature {
+    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_size_feature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_size_feature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_size_feature_boolean(
-        &mut self,
-        node: SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureBoolean {
+    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature_boolean(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature_boolean(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_boolean(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_boolean(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_size_feature_name(
-        &mut self,
-        node: SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureName {
+    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_size_feature_plain(
-        &mut self,
-        node: SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeaturePlain {
+    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature_plain(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature_plain(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_plain(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_plain(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_size_feature_range(
-        &mut self,
-        node: SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureRange {
+    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature_range(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_range(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_range(visitor, node),
         }
     }
 
@@ -96405,14 +78414,13 @@ where
     fn fold_size_feature_range_comparison(
         &mut self,
         node: SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeComparison {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature_range_comparison(visitor, node, __ast_path)
+                Fold::fold_size_feature_range_comparison(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature_range_comparison(visitor, node, __ast_path)
+                Fold::fold_size_feature_range_comparison(visitor, node)
             }
         }
     }
@@ -96421,139 +78429,86 @@ where
     fn fold_size_feature_range_interval(
         &mut self,
         node: SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeInterval {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature_range_interval(visitor, node, __ast_path)
+                Fold::fold_size_feature_range_interval(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature_range_interval(visitor, node, __ast_path)
+                Fold::fold_size_feature_range_interval(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_size_feature_value(
-        &mut self,
-        node: SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureValue {
+    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_size_feature_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_size_feature_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_size_feature_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_size_feature_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_span(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_span(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+    fn fold_str(&mut self, node: Str) -> Str {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_str(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_str(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
+    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_style_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_style_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_style_block(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_style_block(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
+    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_stylesheet(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_stylesheet(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_stylesheet(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_stylesheet(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_subclass_selector(
-        &mut self,
-        node: SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> SubclassSelector {
+    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_subclass_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_subclass_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_subclass_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_subclass_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_subclass_selectors(
-        &mut self,
-        node: Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SubclassSelector> {
+    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_subclass_selectors(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_subclass_selectors(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_subclass_selectors(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_subclass_selectors(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_supports_and(
-        &mut self,
-        node: SupportsAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsAnd {
+    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_and(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_and(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_and(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_and(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_supports_condition(
-        &mut self,
-        node: SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsCondition {
+    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_condition(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_condition(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_condition(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_condition(visitor, node),
         }
     }
 
@@ -96561,15 +78516,10 @@ where
     fn fold_supports_condition_type(
         &mut self,
         node: SupportsConditionType,
-        __ast_path: &mut AstKindPath,
     ) -> SupportsConditionType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_condition_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_condition_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_condition_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_condition_type(visitor, node),
         }
     }
 
@@ -96577,439 +78527,280 @@ where
     fn fold_supports_condition_types(
         &mut self,
         node: Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<SupportsConditionType> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_condition_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_condition_types(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_condition_types(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_condition_types(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_supports_feature(
-        &mut self,
-        node: SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsFeature {
+    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_feature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_feature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_feature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_feature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_supports_in_parens(
-        &mut self,
-        node: SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsInParens {
+    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_in_parens(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_in_parens(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_in_parens(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_in_parens(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_supports_not(
-        &mut self,
-        node: SupportsNot,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsNot {
+    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_not(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_not(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_not(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_not(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
+    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_supports_or(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_supports_or(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_supports_or(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_supports_or(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_tag_name_selector(
-        &mut self,
-        node: TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TagNameSelector {
+    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_tag_name_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_tag_name_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_tag_name_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_tag_name_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
+    fn fold_time(&mut self, node: Time) -> Time {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_time(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_time(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_time(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_time(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_time_percentage(
-        &mut self,
-        node: TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> TimePercentage {
+    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_time_percentage(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_time_percentage(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_time_percentage(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_time_percentage(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
+    fn fold_token(&mut self, node: Token) -> Token {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_token(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_token(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_token(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_token(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_token_and_span(
-        &mut self,
-        node: TokenAndSpan,
-        __ast_path: &mut AstKindPath,
-    ) -> TokenAndSpan {
+    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_token_and_span(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_token_and_span(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_token_and_span(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_token_and_span(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_type_selector(
-        &mut self,
-        node: TypeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TypeSelector {
+    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_type_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_type_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_type_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_type_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_unicode_range(
-        &mut self,
-        node: UnicodeRange,
-        __ast_path: &mut AstKindPath,
-    ) -> UnicodeRange {
+    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_unicode_range(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_unicode_range(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_unicode_range(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_unicode_range(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_universal_selector(
-        &mut self,
-        node: UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> UniversalSelector {
+    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_universal_selector(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_universal_selector(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_universal_selector(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_universal_selector(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_unknown_dimension(
-        &mut self,
-        node: UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) -> UnknownDimension {
+    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_unknown_dimension(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_unknown_dimension(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_unknown_dimension(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_unknown_dimension(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
+    fn fold_url(&mut self, node: Url) -> Url {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_url(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_url(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_url(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_url(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_url_key_value(
-        &mut self,
-        node: UrlKeyValue,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlKeyValue {
+    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_url_key_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_url_key_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_url_key_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_url_key_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_url_modifier(
-        &mut self,
-        node: UrlModifier,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlModifier {
+    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_url_modifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_url_modifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_url_modifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_url_modifier(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_url_modifiers(
-        &mut self,
-        node: Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<UrlModifier> {
+    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_url_modifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_url_modifiers(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_url_modifiers(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_url_modifiers(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
+    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_url_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_url_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_url_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_url_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_url_value_raw(
-        &mut self,
-        node: UrlValueRaw,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlValueRaw {
+    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_url_value_raw(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_url_value_raw(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_url_value_raw(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_url_value_raw(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
+    fn fold_wq_name(&mut self, node: WqName) -> WqName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_wq_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_wq_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_wq_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_wq_name(visitor, node),
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> FoldAstPath for ::swc_visit::Optional<V>
+impl<V> Fold for ::swc_visit::Optional<V>
 where
-    V: FoldAstPath,
+    V: Fold,
 {
     #[inline]
-    fn fold_absolute_color_base(
-        &mut self,
-        node: AbsoluteColorBase,
-        __ast_path: &mut AstKindPath,
-    ) -> AbsoluteColorBase {
+    fn fold_absolute_color_base(&mut self, node: AbsoluteColorBase) -> AbsoluteColorBase {
         if self.enabled {
-            <V as FoldAstPath>::fold_absolute_color_base(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_absolute_color_base(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
+    fn fold_alpha_value(&mut self, node: AlphaValue) -> AlphaValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_alpha_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_alpha_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
+    fn fold_an_plus_b(&mut self, node: AnPlusB) -> AnPlusB {
         if self.enabled {
-            <V as FoldAstPath>::fold_an_plus_b(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_an_plus_b(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_an_plus_b_notation(
-        &mut self,
-        node: AnPlusBNotation,
-        __ast_path: &mut AstKindPath,
-    ) -> AnPlusBNotation {
+    fn fold_an_plus_b_notation(&mut self, node: AnPlusBNotation) -> AnPlusBNotation {
         if self.enabled {
-            <V as FoldAstPath>::fold_an_plus_b_notation(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_an_plus_b_notation(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
+    fn fold_angle(&mut self, node: Angle) -> Angle {
         if self.enabled {
-            <V as FoldAstPath>::fold_angle(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_angle(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_angle_percentage(
-        &mut self,
-        node: AnglePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> AnglePercentage {
+    fn fold_angle_percentage(&mut self, node: AnglePercentage) -> AnglePercentage {
         if self.enabled {
-            <V as FoldAstPath>::fold_angle_percentage(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_angle_percentage(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_any_namespace(
-        &mut self,
-        node: AnyNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> AnyNamespace {
+    fn fold_any_namespace(&mut self, node: AnyNamespace) -> AnyNamespace {
         if self.enabled {
-            <V as FoldAstPath>::fold_any_namespace(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_any_namespace(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
+    fn fold_at_rule(&mut self, node: AtRule) -> AtRule {
         if self.enabled {
-            <V as FoldAstPath>::fold_at_rule(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_at_rule(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
+    fn fold_at_rule_name(&mut self, node: AtRuleName) -> AtRuleName {
         if self.enabled {
-            <V as FoldAstPath>::fold_at_rule_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_at_rule_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_at_rule_prelude(
-        &mut self,
-        node: AtRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> AtRulePrelude {
+    fn fold_at_rule_prelude(&mut self, node: AtRulePrelude) -> AtRulePrelude {
         if self.enabled {
-            <V as FoldAstPath>::fold_at_rule_prelude(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_at_rule_prelude(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
         if self.enabled {
-            <V as FoldAstPath>::fold_atom(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_atom(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_attribute_selector(
-        &mut self,
-        node: AttributeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> AttributeSelector {
+    fn fold_attribute_selector(&mut self, node: AttributeSelector) -> AttributeSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_attribute_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_attribute_selector(&mut self.visitor, node)
         } else {
             node
         }
@@ -97019,10 +78810,9 @@ where
     fn fold_attribute_selector_matcher(
         &mut self,
         node: AttributeSelectorMatcher,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcher {
         if self.enabled {
-            <V as FoldAstPath>::fold_attribute_selector_matcher(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_attribute_selector_matcher(&mut self.visitor, node)
         } else {
             node
         }
@@ -97032,14 +78822,9 @@ where
     fn fold_attribute_selector_matcher_value(
         &mut self,
         node: AttributeSelectorMatcherValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorMatcherValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_attribute_selector_matcher_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_attribute_selector_matcher_value(&mut self.visitor, node)
         } else {
             node
         }
@@ -97049,14 +78834,9 @@ where
     fn fold_attribute_selector_modifier(
         &mut self,
         node: AttributeSelectorModifier,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorModifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_attribute_selector_modifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_attribute_selector_modifier(&mut self.visitor, node)
         } else {
             node
         }
@@ -97066,58 +78846,45 @@ where
     fn fold_attribute_selector_value(
         &mut self,
         node: AttributeSelectorValue,
-        __ast_path: &mut AstKindPath,
     ) -> AttributeSelectorValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_attribute_selector_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_attribute_selector_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
+    fn fold_bin_op(&mut self, node: BinOp) -> BinOp {
         if self.enabled {
-            <V as FoldAstPath>::fold_bin_op(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_bin_op(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_calc_operator(
-        &mut self,
-        node: CalcOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperator {
+    fn fold_calc_operator(&mut self, node: CalcOperator) -> CalcOperator {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_operator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_operator(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_calc_operator_type(
-        &mut self,
-        node: CalcOperatorType,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcOperatorType {
+    fn fold_calc_operator_type(&mut self, node: CalcOperatorType) -> CalcOperatorType {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_operator_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_operator_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_calc_product(
-        &mut self,
-        node: CalcProduct,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcProduct {
+    fn fold_calc_product(&mut self, node: CalcProduct) -> CalcProduct {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_product(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_product(&mut self.visitor, node)
         } else {
             node
         }
@@ -97127,10 +78894,9 @@ where
     fn fold_calc_product_or_operator(
         &mut self,
         node: CalcProductOrOperator,
-        __ast_path: &mut AstKindPath,
     ) -> CalcProductOrOperator {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_product_or_operator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_product_or_operator(&mut self.visitor, node)
         } else {
             node
         }
@@ -97140,41 +78906,36 @@ where
     fn fold_calc_product_or_operators(
         &mut self,
         node: Vec<CalcProductOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcProductOrOperator> {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_product_or_operators(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_product_or_operators(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
+    fn fold_calc_sum(&mut self, node: CalcSum) -> CalcSum {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_sum(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_sum(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
+    fn fold_calc_value(&mut self, node: CalcValue) -> CalcValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_calc_value_or_operator(
-        &mut self,
-        node: CalcValueOrOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> CalcValueOrOperator {
+    fn fold_calc_value_or_operator(&mut self, node: CalcValueOrOperator) -> CalcValueOrOperator {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_value_or_operator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_value_or_operator(&mut self.visitor, node)
         } else {
             node
         }
@@ -97184,93 +78945,72 @@ where
     fn fold_calc_value_or_operators(
         &mut self,
         node: Vec<CalcValueOrOperator>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<CalcValueOrOperator> {
         if self.enabled {
-            <V as FoldAstPath>::fold_calc_value_or_operators(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_calc_value_or_operators(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class_selector(
-        &mut self,
-        node: ClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassSelector {
+    fn fold_class_selector(&mut self, node: ClassSelector) -> ClassSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_class_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_cmyk_component(
-        &mut self,
-        node: CmykComponent,
-        __ast_path: &mut AstKindPath,
-    ) -> CmykComponent {
+    fn fold_cmyk_component(&mut self, node: CmykComponent) -> CmykComponent {
         if self.enabled {
-            <V as FoldAstPath>::fold_cmyk_component(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_cmyk_component(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
+    fn fold_color(&mut self, node: Color) -> Color {
         if self.enabled {
-            <V as FoldAstPath>::fold_color(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_color(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_color_profile_name(
-        &mut self,
-        node: ColorProfileName,
-        __ast_path: &mut AstKindPath,
-    ) -> ColorProfileName {
+    fn fold_color_profile_name(&mut self, node: ColorProfileName) -> ColorProfileName {
         if self.enabled {
-            <V as FoldAstPath>::fold_color_profile_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_color_profile_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
+    fn fold_combinator(&mut self, node: Combinator) -> Combinator {
         if self.enabled {
-            <V as FoldAstPath>::fold_combinator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_combinator(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_combinator_value(
-        &mut self,
-        node: CombinatorValue,
-        __ast_path: &mut AstKindPath,
-    ) -> CombinatorValue {
+    fn fold_combinator_value(&mut self, node: CombinatorValue) -> CombinatorValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_combinator_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_combinator_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_complex_selector(
-        &mut self,
-        node: ComplexSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> ComplexSelector {
+    fn fold_complex_selector(&mut self, node: ComplexSelector) -> ComplexSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_complex_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_complex_selector(&mut self.visitor, node)
         } else {
             node
         }
@@ -97280,10 +79020,9 @@ where
     fn fold_complex_selector_children(
         &mut self,
         node: ComplexSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> ComplexSelectorChildren {
         if self.enabled {
-            <V as FoldAstPath>::fold_complex_selector_children(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_complex_selector_children(&mut self.visitor, node)
         } else {
             node
         }
@@ -97293,179 +79032,126 @@ where
     fn fold_complex_selector_childrens(
         &mut self,
         node: Vec<ComplexSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ComplexSelectorChildren> {
         if self.enabled {
-            <V as FoldAstPath>::fold_complex_selector_childrens(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_complex_selector_childrens(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_complex_selectors(
-        &mut self,
-        node: Vec<ComplexSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComplexSelector> {
+    fn fold_complex_selectors(&mut self, node: Vec<ComplexSelector>) -> Vec<ComplexSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_complex_selectors(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_complex_selectors(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_component_value(
-        &mut self,
-        node: ComponentValue,
-        __ast_path: &mut AstKindPath,
-    ) -> ComponentValue {
+    fn fold_component_value(&mut self, node: ComponentValue) -> ComponentValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_component_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_component_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_component_values(
-        &mut self,
-        node: Vec<ComponentValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ComponentValue> {
+    fn fold_component_values(&mut self, node: Vec<ComponentValue>) -> Vec<ComponentValue> {
         if self.enabled {
-            <V as FoldAstPath>::fold_component_values(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_component_values(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_compound_selector(
-        &mut self,
-        node: CompoundSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelector {
+    fn fold_compound_selector(&mut self, node: CompoundSelector) -> CompoundSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_compound_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_compound_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_compound_selector_list(
-        &mut self,
-        node: CompoundSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> CompoundSelectorList {
+    fn fold_compound_selector_list(&mut self, node: CompoundSelectorList) -> CompoundSelectorList {
         if self.enabled {
-            <V as FoldAstPath>::fold_compound_selector_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_compound_selector_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_compound_selectors(
-        &mut self,
-        node: Vec<CompoundSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CompoundSelector> {
+    fn fold_compound_selectors(&mut self, node: Vec<CompoundSelector>) -> Vec<CompoundSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_compound_selectors(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_compound_selectors(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_container_condition(
-        &mut self,
-        node: ContainerCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerCondition {
+    fn fold_container_condition(&mut self, node: ContainerCondition) -> ContainerCondition {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_condition(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_condition(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_container_name(
-        &mut self,
-        node: ContainerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerName {
+    fn fold_container_name(&mut self, node: ContainerName) -> ContainerName {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_container_query(
-        &mut self,
-        node: ContainerQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQuery {
+    fn fold_container_query(&mut self, node: ContainerQuery) -> ContainerQuery {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_query(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_query(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_container_query_and(
-        &mut self,
-        node: ContainerQueryAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryAnd {
+    fn fold_container_query_and(&mut self, node: ContainerQueryAnd) -> ContainerQueryAnd {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_query_and(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_query_and(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_container_query_not(
-        &mut self,
-        node: ContainerQueryNot,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryNot {
+    fn fold_container_query_not(&mut self, node: ContainerQueryNot) -> ContainerQueryNot {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_query_not(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_query_not(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_container_query_or(
-        &mut self,
-        node: ContainerQueryOr,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryOr {
+    fn fold_container_query_or(&mut self, node: ContainerQueryOr) -> ContainerQueryOr {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_query_or(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_query_or(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_container_query_type(
-        &mut self,
-        node: ContainerQueryType,
-        __ast_path: &mut AstKindPath,
-    ) -> ContainerQueryType {
+    fn fold_container_query_type(&mut self, node: ContainerQueryType) -> ContainerQueryType {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_query_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_query_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -97475,62 +79161,45 @@ where
     fn fold_container_query_types(
         &mut self,
         node: Vec<ContainerQueryType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ContainerQueryType> {
         if self.enabled {
-            <V as FoldAstPath>::fold_container_query_types(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_container_query_types(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_custom_highlight_name(
-        &mut self,
-        node: CustomHighlightName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomHighlightName {
+    fn fold_custom_highlight_name(&mut self, node: CustomHighlightName) -> CustomHighlightName {
         if self.enabled {
-            <V as FoldAstPath>::fold_custom_highlight_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_custom_highlight_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_custom_ident(
-        &mut self,
-        node: CustomIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomIdent {
+    fn fold_custom_ident(&mut self, node: CustomIdent) -> CustomIdent {
         if self.enabled {
-            <V as FoldAstPath>::fold_custom_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_custom_ident(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_custom_idents(
-        &mut self,
-        node: Vec<CustomIdent>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<CustomIdent> {
+    fn fold_custom_idents(&mut self, node: Vec<CustomIdent>) -> Vec<CustomIdent> {
         if self.enabled {
-            <V as FoldAstPath>::fold_custom_idents(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_custom_idents(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_custom_media_query(
-        &mut self,
-        node: CustomMediaQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomMediaQuery {
+    fn fold_custom_media_query(&mut self, node: CustomMediaQuery) -> CustomMediaQuery {
         if self.enabled {
-            <V as FoldAstPath>::fold_custom_media_query(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_custom_media_query(&mut self.visitor, node)
         } else {
             node
         }
@@ -97540,132 +79209,99 @@ where
     fn fold_custom_media_query_media_type(
         &mut self,
         node: CustomMediaQueryMediaType,
-        __ast_path: &mut AstKindPath,
     ) -> CustomMediaQueryMediaType {
         if self.enabled {
-            <V as FoldAstPath>::fold_custom_media_query_media_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_custom_media_query_media_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_custom_property_name(
-        &mut self,
-        node: CustomPropertyName,
-        __ast_path: &mut AstKindPath,
-    ) -> CustomPropertyName {
+    fn fold_custom_property_name(&mut self, node: CustomPropertyName) -> CustomPropertyName {
         if self.enabled {
-            <V as FoldAstPath>::fold_custom_property_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_custom_property_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_dashed_ident(
-        &mut self,
-        node: DashedIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> DashedIdent {
+    fn fold_dashed_ident(&mut self, node: DashedIdent) -> DashedIdent {
         if self.enabled {
-            <V as FoldAstPath>::fold_dashed_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_dashed_ident(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
+    fn fold_declaration(&mut self, node: Declaration) -> Declaration {
         if self.enabled {
-            <V as FoldAstPath>::fold_declaration(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_declaration(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_declaration_name(
-        &mut self,
-        node: DeclarationName,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationName {
+    fn fold_declaration_name(&mut self, node: DeclarationName) -> DeclarationName {
         if self.enabled {
-            <V as FoldAstPath>::fold_declaration_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_declaration_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_declaration_or_at_rule(
-        &mut self,
-        node: DeclarationOrAtRule,
-        __ast_path: &mut AstKindPath,
-    ) -> DeclarationOrAtRule {
+    fn fold_declaration_or_at_rule(&mut self, node: DeclarationOrAtRule) -> DeclarationOrAtRule {
         if self.enabled {
-            <V as FoldAstPath>::fold_declaration_or_at_rule(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_declaration_or_at_rule(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
+    fn fold_delimiter(&mut self, node: Delimiter) -> Delimiter {
         if self.enabled {
-            <V as FoldAstPath>::fold_delimiter(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_delimiter(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_delimiter_value(
-        &mut self,
-        node: DelimiterValue,
-        __ast_path: &mut AstKindPath,
-    ) -> DelimiterValue {
+    fn fold_delimiter_value(&mut self, node: DelimiterValue) -> DelimiterValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_delimiter_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_delimiter_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
+    fn fold_dimension(&mut self, node: Dimension) -> Dimension {
         if self.enabled {
-            <V as FoldAstPath>::fold_dimension(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_dimension(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_dimension_token(
-        &mut self,
-        node: DimensionToken,
-        __ast_path: &mut AstKindPath,
-    ) -> DimensionToken {
+    fn fold_dimension_token(&mut self, node: DimensionToken) -> DimensionToken {
         if self.enabled {
-            <V as FoldAstPath>::fold_dimension_token(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_dimension_token(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_document_prelude(
-        &mut self,
-        node: DocumentPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> DocumentPrelude {
+    fn fold_document_prelude(&mut self, node: DocumentPrelude) -> DocumentPrelude {
         if self.enabled {
-            <V as FoldAstPath>::fold_document_prelude(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_document_prelude(&mut self.visitor, node)
         } else {
             node
         }
@@ -97675,14 +79311,9 @@ where
     fn fold_document_prelude_matching_function(
         &mut self,
         node: DocumentPreludeMatchingFunction,
-        __ast_path: &mut AstKindPath,
     ) -> DocumentPreludeMatchingFunction {
         if self.enabled {
-            <V as FoldAstPath>::fold_document_prelude_matching_function(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_document_prelude_matching_function(&mut self.visitor, node)
         } else {
             node
         }
@@ -97692,58 +79323,45 @@ where
     fn fold_document_prelude_matching_functions(
         &mut self,
         node: Vec<DocumentPreludeMatchingFunction>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<DocumentPreludeMatchingFunction> {
         if self.enabled {
-            <V as FoldAstPath>::fold_document_prelude_matching_functions(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_document_prelude_matching_functions(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_extension_name(
-        &mut self,
-        node: ExtensionName,
-        __ast_path: &mut AstKindPath,
-    ) -> ExtensionName {
+    fn fold_extension_name(&mut self, node: ExtensionName) -> ExtensionName {
         if self.enabled {
-            <V as FoldAstPath>::fold_extension_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_extension_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
+    fn fold_family_name(&mut self, node: FamilyName) -> FamilyName {
         if self.enabled {
-            <V as FoldAstPath>::fold_family_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_family_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_family_names(
-        &mut self,
-        node: Vec<FamilyName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<FamilyName> {
+    fn fold_family_names(&mut self, node: Vec<FamilyName>) -> Vec<FamilyName> {
         if self.enabled {
-            <V as FoldAstPath>::fold_family_names(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_family_names(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
+    fn fold_flex(&mut self, node: Flex) -> Flex {
         if self.enabled {
-            <V as FoldAstPath>::fold_flex(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_flex(&mut self.visitor, node)
         } else {
             node
         }
@@ -97753,14 +79371,9 @@ where
     fn fold_font_feature_values_prelude(
         &mut self,
         node: FontFeatureValuesPrelude,
-        __ast_path: &mut AstKindPath,
     ) -> FontFeatureValuesPrelude {
         if self.enabled {
-            <V as FoldAstPath>::fold_font_feature_values_prelude(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_font_feature_values_prelude(&mut self.visitor, node)
         } else {
             node
         }
@@ -97770,10 +79383,9 @@ where
     fn fold_forgiving_complex_selector(
         &mut self,
         node: ForgivingComplexSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingComplexSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_forgiving_complex_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_forgiving_complex_selector(&mut self.visitor, node)
         } else {
             node
         }
@@ -97783,14 +79395,9 @@ where
     fn fold_forgiving_complex_selectors(
         &mut self,
         node: Vec<ForgivingComplexSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingComplexSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_forgiving_complex_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_forgiving_complex_selectors(&mut self.visitor, node)
         } else {
             node
         }
@@ -97800,14 +79407,9 @@ where
     fn fold_forgiving_relative_selector(
         &mut self,
         node: ForgivingRelativeSelector,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_forgiving_relative_selector(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_forgiving_relative_selector(&mut self.visitor, node)
         } else {
             node
         }
@@ -97817,14 +79419,9 @@ where
     fn fold_forgiving_relative_selector_list(
         &mut self,
         node: ForgivingRelativeSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingRelativeSelectorList {
         if self.enabled {
-            <V as FoldAstPath>::fold_forgiving_relative_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_forgiving_relative_selector_list(&mut self.visitor, node)
         } else {
             node
         }
@@ -97834,14 +79431,9 @@ where
     fn fold_forgiving_relative_selectors(
         &mut self,
         node: Vec<ForgivingRelativeSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ForgivingRelativeSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_forgiving_relative_selectors(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_forgiving_relative_selectors(&mut self.visitor, node)
         } else {
             node
         }
@@ -97851,234 +79443,189 @@ where
     fn fold_forgiving_selector_list(
         &mut self,
         node: ForgivingSelectorList,
-        __ast_path: &mut AstKindPath,
     ) -> ForgivingSelectorList {
         if self.enabled {
-            <V as FoldAstPath>::fold_forgiving_selector_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_forgiving_selector_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
+    fn fold_frequency(&mut self, node: Frequency) -> Frequency {
         if self.enabled {
-            <V as FoldAstPath>::fold_frequency(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_frequency(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_frequency_percentage(
-        &mut self,
-        node: FrequencyPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> FrequencyPercentage {
+    fn fold_frequency_percentage(&mut self, node: FrequencyPercentage) -> FrequencyPercentage {
         if self.enabled {
-            <V as FoldAstPath>::fold_frequency_percentage(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_frequency_percentage(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+    fn fold_function(&mut self, node: Function) -> Function {
         if self.enabled {
-            <V as FoldAstPath>::fold_function(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_function(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_function_name(
-        &mut self,
-        node: FunctionName,
-        __ast_path: &mut AstKindPath,
-    ) -> FunctionName {
+    fn fold_function_name(&mut self, node: FunctionName) -> FunctionName {
         if self.enabled {
-            <V as FoldAstPath>::fold_function_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_function_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_general_enclosed(
-        &mut self,
-        node: GeneralEnclosed,
-        __ast_path: &mut AstKindPath,
-    ) -> GeneralEnclosed {
+    fn fold_general_enclosed(&mut self, node: GeneralEnclosed) -> GeneralEnclosed {
         if self.enabled {
-            <V as FoldAstPath>::fold_general_enclosed(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_general_enclosed(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
+    fn fold_hex_color(&mut self, node: HexColor) -> HexColor {
         if self.enabled {
-            <V as FoldAstPath>::fold_hex_color(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_hex_color(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
+    fn fold_hue(&mut self, node: Hue) -> Hue {
         if self.enabled {
-            <V as FoldAstPath>::fold_hue(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_hue(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
+    fn fold_id_selector(&mut self, node: IdSelector) -> IdSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_id_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_id_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+    fn fold_ident(&mut self, node: Ident) -> Ident {
         if self.enabled {
-            <V as FoldAstPath>::fold_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ident(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
+    fn fold_idents(&mut self, node: Vec<Ident>) -> Vec<Ident> {
         if self.enabled {
-            <V as FoldAstPath>::fold_idents(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_idents(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_conditions(
-        &mut self,
-        node: ImportConditions,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportConditions {
+    fn fold_import_conditions(&mut self, node: ImportConditions) -> ImportConditions {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_conditions(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_conditions(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
+    fn fold_import_href(&mut self, node: ImportHref) -> ImportHref {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_href(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_href(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_layer_name(
-        &mut self,
-        node: ImportLayerName,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportLayerName {
+    fn fold_import_layer_name(&mut self, node: ImportLayerName) -> ImportLayerName {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_layer_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_layer_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_prelude(
-        &mut self,
-        node: ImportPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPrelude {
+    fn fold_import_prelude(&mut self, node: ImportPrelude) -> ImportPrelude {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_prelude(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_prelude(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_important_flag(
-        &mut self,
-        node: ImportantFlag,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportantFlag {
+    fn fold_important_flag(&mut self, node: ImportantFlag) -> ImportantFlag {
         if self.enabled {
-            <V as FoldAstPath>::fold_important_flag(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_important_flag(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
+    fn fold_integer(&mut self, node: Integer) -> Integer {
         if self.enabled {
-            <V as FoldAstPath>::fold_integer(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_integer(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_keyframe_block(
-        &mut self,
-        node: KeyframeBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeBlock {
+    fn fold_keyframe_block(&mut self, node: KeyframeBlock) -> KeyframeBlock {
         if self.enabled {
-            <V as FoldAstPath>::fold_keyframe_block(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_keyframe_block(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_keyframe_selector(
-        &mut self,
-        node: KeyframeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframeSelector {
+    fn fold_keyframe_selector(&mut self, node: KeyframeSelector) -> KeyframeSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_keyframe_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_keyframe_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_keyframe_selectors(
-        &mut self,
-        node: Vec<KeyframeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<KeyframeSelector> {
+    fn fold_keyframe_selectors(&mut self, node: Vec<KeyframeSelector>) -> Vec<KeyframeSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_keyframe_selectors(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_keyframe_selectors(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_keyframes_name(
-        &mut self,
-        node: KeyframesName,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyframesName {
+    fn fold_keyframes_name(&mut self, node: KeyframesName) -> KeyframesName {
         if self.enabled {
-            <V as FoldAstPath>::fold_keyframes_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_keyframes_name(&mut self.visitor, node)
         } else {
             node
         }
@@ -98088,10 +79635,9 @@ where
     fn fold_keyframes_pseudo_function(
         &mut self,
         node: KeyframesPseudoFunction,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoFunction {
         if self.enabled {
-            <V as FoldAstPath>::fold_keyframes_pseudo_function(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_keyframes_pseudo_function(&mut self.visitor, node)
         } else {
             node
         }
@@ -98101,80 +79647,63 @@ where
     fn fold_keyframes_pseudo_prefix(
         &mut self,
         node: KeyframesPseudoPrefix,
-        __ast_path: &mut AstKindPath,
     ) -> KeyframesPseudoPrefix {
         if self.enabled {
-            <V as FoldAstPath>::fold_keyframes_pseudo_prefix(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_keyframes_pseudo_prefix(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
+    fn fold_layer_name(&mut self, node: LayerName) -> LayerName {
         if self.enabled {
-            <V as FoldAstPath>::fold_layer_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_layer_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_layer_name_list(
-        &mut self,
-        node: LayerNameList,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerNameList {
+    fn fold_layer_name_list(&mut self, node: LayerNameList) -> LayerNameList {
         if self.enabled {
-            <V as FoldAstPath>::fold_layer_name_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_layer_name_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_layer_names(
-        &mut self,
-        node: Vec<LayerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<LayerName> {
+    fn fold_layer_names(&mut self, node: Vec<LayerName>) -> Vec<LayerName> {
         if self.enabled {
-            <V as FoldAstPath>::fold_layer_names(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_layer_names(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_layer_prelude(
-        &mut self,
-        node: LayerPrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> LayerPrelude {
+    fn fold_layer_prelude(&mut self, node: LayerPrelude) -> LayerPrelude {
         if self.enabled {
-            <V as FoldAstPath>::fold_layer_prelude(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_layer_prelude(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
+    fn fold_length(&mut self, node: Length) -> Length {
         if self.enabled {
-            <V as FoldAstPath>::fold_length(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_length(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_length_percentage(
-        &mut self,
-        node: LengthPercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> LengthPercentage {
+    fn fold_length_percentage(&mut self, node: LengthPercentage) -> LengthPercentage {
         if self.enabled {
-            <V as FoldAstPath>::fold_length_percentage(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_length_percentage(&mut self.visitor, node)
         } else {
             node
         }
@@ -98184,32 +79713,27 @@ where
     fn fold_list_of_component_values(
         &mut self,
         node: ListOfComponentValues,
-        __ast_path: &mut AstKindPath,
     ) -> ListOfComponentValues {
         if self.enabled {
-            <V as FoldAstPath>::fold_list_of_component_values(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_list_of_component_values(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
+    fn fold_media_and(&mut self, node: MediaAnd) -> MediaAnd {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_and(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_and(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_condition(
-        &mut self,
-        node: MediaCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaCondition {
+    fn fold_media_condition(&mut self, node: MediaCondition) -> MediaCondition {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_condition(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_condition(&mut self.visitor, node)
         } else {
             node
         }
@@ -98219,10 +79743,9 @@ where
     fn fold_media_condition_all_type(
         &mut self,
         node: MediaConditionAllType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionAllType {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_condition_all_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_condition_all_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -98232,23 +79755,18 @@ where
     fn fold_media_condition_all_types(
         &mut self,
         node: Vec<MediaConditionAllType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionAllType> {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_condition_all_types(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_condition_all_types(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_condition_type(
-        &mut self,
-        node: MediaConditionType,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaConditionType {
+    fn fold_media_condition_type(&mut self, node: MediaConditionType) -> MediaConditionType {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_condition_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_condition_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -98258,10 +79776,9 @@ where
     fn fold_media_condition_without_or(
         &mut self,
         node: MediaConditionWithoutOr,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOr {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_condition_without_or(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_condition_without_or(&mut self.visitor, node)
         } else {
             node
         }
@@ -98271,14 +79788,9 @@ where
     fn fold_media_condition_without_or_type(
         &mut self,
         node: MediaConditionWithoutOrType,
-        __ast_path: &mut AstKindPath,
     ) -> MediaConditionWithoutOrType {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_condition_without_or_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_media_condition_without_or_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -98288,79 +79800,54 @@ where
     fn fold_media_condition_without_or_types(
         &mut self,
         node: Vec<MediaConditionWithoutOrType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<MediaConditionWithoutOrType> {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_condition_without_or_types(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_media_condition_without_or_types(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_feature(
-        &mut self,
-        node: MediaFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeature {
+    fn fold_media_feature(&mut self, node: MediaFeature) -> MediaFeature {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_feature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_feature_boolean(
-        &mut self,
-        node: MediaFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureBoolean {
+    fn fold_media_feature_boolean(&mut self, node: MediaFeatureBoolean) -> MediaFeatureBoolean {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature_boolean(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_feature_boolean(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_feature_name(
-        &mut self,
-        node: MediaFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureName {
+    fn fold_media_feature_name(&mut self, node: MediaFeatureName) -> MediaFeatureName {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_feature_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_feature_plain(
-        &mut self,
-        node: MediaFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeaturePlain {
+    fn fold_media_feature_plain(&mut self, node: MediaFeaturePlain) -> MediaFeaturePlain {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature_plain(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_feature_plain(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_feature_range(
-        &mut self,
-        node: MediaFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureRange {
+    fn fold_media_feature_range(&mut self, node: MediaFeatureRange) -> MediaFeatureRange {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature_range(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_feature_range(&mut self.visitor, node)
         } else {
             node
         }
@@ -98370,14 +79857,9 @@ where
     fn fold_media_feature_range_comparison(
         &mut self,
         node: MediaFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeComparison {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature_range_comparison(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_media_feature_range_comparison(&mut self.visitor, node)
         } else {
             node
         }
@@ -98387,194 +79869,153 @@ where
     fn fold_media_feature_range_interval(
         &mut self,
         node: MediaFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> MediaFeatureRangeInterval {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature_range_interval(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_media_feature_range_interval(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_feature_value(
-        &mut self,
-        node: MediaFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaFeatureValue {
+    fn fold_media_feature_value(&mut self, node: MediaFeatureValue) -> MediaFeatureValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_feature_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_feature_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_in_parens(
-        &mut self,
-        node: MediaInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaInParens {
+    fn fold_media_in_parens(&mut self, node: MediaInParens) -> MediaInParens {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_in_parens(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_in_parens(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
+    fn fold_media_not(&mut self, node: MediaNot) -> MediaNot {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_not(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_not(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
+    fn fold_media_or(&mut self, node: MediaOr) -> MediaOr {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_or(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_or(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
+    fn fold_media_query(&mut self, node: MediaQuery) -> MediaQuery {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_query(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_query(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_query_list(
-        &mut self,
-        node: MediaQueryList,
-        __ast_path: &mut AstKindPath,
-    ) -> MediaQueryList {
+    fn fold_media_query_list(&mut self, node: MediaQueryList) -> MediaQueryList {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_query_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_query_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_querys(
-        &mut self,
-        node: Vec<MediaQuery>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<MediaQuery> {
+    fn fold_media_querys(&mut self, node: Vec<MediaQuery>) -> Vec<MediaQuery> {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_querys(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_querys(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
+    fn fold_media_type(&mut self, node: MediaType) -> MediaType {
         if self.enabled {
-            <V as FoldAstPath>::fold_media_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_media_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_named_namespace(
-        &mut self,
-        node: NamedNamespace,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedNamespace {
+    fn fold_named_namespace(&mut self, node: NamedNamespace) -> NamedNamespace {
         if self.enabled {
-            <V as FoldAstPath>::fold_named_namespace(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_named_namespace(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
+    fn fold_namespace(&mut self, node: Namespace) -> Namespace {
         if self.enabled {
-            <V as FoldAstPath>::fold_namespace(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_namespace(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_namespace_prefix(
-        &mut self,
-        node: NamespacePrefix,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrefix {
+    fn fold_namespace_prefix(&mut self, node: NamespacePrefix) -> NamespacePrefix {
         if self.enabled {
-            <V as FoldAstPath>::fold_namespace_prefix(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_namespace_prefix(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude(
-        &mut self,
-        node: NamespacePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePrelude {
+    fn fold_namespace_prelude(&mut self, node: NamespacePrelude) -> NamespacePrelude {
         if self.enabled {
-            <V as FoldAstPath>::fold_namespace_prelude(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_namespace_prelude(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_namespace_prelude_uri(
-        &mut self,
-        node: NamespacePreludeUri,
-        __ast_path: &mut AstKindPath,
-    ) -> NamespacePreludeUri {
+    fn fold_namespace_prelude_uri(&mut self, node: NamespacePreludeUri) -> NamespacePreludeUri {
         if self.enabled {
-            <V as FoldAstPath>::fold_namespace_prelude_uri(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_namespace_prelude_uri(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_nesting_selector(
-        &mut self,
-        node: NestingSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> NestingSelector {
+    fn fold_nesting_selector(&mut self, node: NestingSelector) -> NestingSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_nesting_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_nesting_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+    fn fold_number(&mut self, node: Number) -> Number {
         if self.enabled {
-            <V as FoldAstPath>::fold_number(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_number(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
+    fn fold_number_type(&mut self, node: NumberType) -> NumberType {
         if self.enabled {
-            <V as FoldAstPath>::fold_number_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_number_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -98584,23 +80025,18 @@ where
     fn fold_opt_at_rule_prelude(
         &mut self,
         node: Option<Box<AtRulePrelude>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<AtRulePrelude>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_at_rule_prelude(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_at_rule_prelude(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_atom(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_atom(&mut self.visitor, node)
         } else {
             node
         }
@@ -98610,14 +80046,9 @@ where
     fn fold_opt_attribute_selector_matcher(
         &mut self,
         node: Option<AttributeSelectorMatcher>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorMatcher> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_attribute_selector_matcher(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_opt_attribute_selector_matcher(&mut self.visitor, node)
         } else {
             node
         }
@@ -98627,14 +80058,9 @@ where
     fn fold_opt_attribute_selector_modifier(
         &mut self,
         node: Option<AttributeSelectorModifier>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorModifier> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_attribute_selector_modifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_opt_attribute_selector_modifier(&mut self.visitor, node)
         } else {
             node
         }
@@ -98644,40 +80070,27 @@ where
     fn fold_opt_attribute_selector_value(
         &mut self,
         node: Option<AttributeSelectorValue>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<AttributeSelectorValue> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_attribute_selector_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_opt_attribute_selector_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_combinator(
-        &mut self,
-        node: Option<Combinator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Combinator> {
+    fn fold_opt_combinator(&mut self, node: Option<Combinator>) -> Option<Combinator> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_combinator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_combinator(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_container_name(
-        &mut self,
-        node: Option<ContainerName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ContainerName> {
+    fn fold_opt_container_name(&mut self, node: Option<ContainerName>) -> Option<ContainerName> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_container_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_container_name(&mut self.visitor, node)
         } else {
             node
         }
@@ -98687,40 +80100,27 @@ where
     fn fold_opt_forgiving_selector_list(
         &mut self,
         node: Option<ForgivingSelectorList>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ForgivingSelectorList> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_forgiving_selector_list(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_opt_forgiving_selector_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_function(
-        &mut self,
-        node: Option<Box<Function>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Function>> {
+    fn fold_opt_function(&mut self, node: Option<Box<Function>>) -> Option<Box<Function>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_function(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_function(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_ident(&mut self.visitor, node)
         } else {
             node
         }
@@ -98730,10 +80130,9 @@ where
     fn fold_opt_import_conditions(
         &mut self,
         node: Option<Box<ImportConditions>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportConditions>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_import_conditions(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_import_conditions(&mut self.visitor, node)
         } else {
             node
         }
@@ -98743,23 +80142,18 @@ where
     fn fold_opt_import_layer_name(
         &mut self,
         node: Option<Box<ImportLayerName>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<ImportLayerName>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_import_layer_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_import_layer_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_important_flag(
-        &mut self,
-        node: Option<ImportantFlag>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ImportantFlag> {
+    fn fold_opt_important_flag(&mut self, node: Option<ImportantFlag>) -> Option<ImportantFlag> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_important_flag(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_important_flag(&mut self.visitor, node)
         } else {
             node
         }
@@ -98769,10 +80163,9 @@ where
     fn fold_opt_media_condition_type(
         &mut self,
         node: Option<Box<MediaConditionType>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaConditionType>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_media_condition_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_media_condition_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -98782,36 +80175,27 @@ where
     fn fold_opt_media_query_list(
         &mut self,
         node: Option<Box<MediaQueryList>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<MediaQueryList>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_media_query_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_media_query_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_media_type(
-        &mut self,
-        node: Option<MediaType>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<MediaType> {
+    fn fold_opt_media_type(&mut self, node: Option<MediaType>) -> Option<MediaType> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_media_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_media_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_namespace(
-        &mut self,
-        node: Option<Namespace>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Namespace> {
+    fn fold_opt_namespace(&mut self, node: Option<Namespace>) -> Option<Namespace> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_namespace(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_namespace(&mut self.visitor, node)
         } else {
             node
         }
@@ -98821,10 +80205,9 @@ where
     fn fold_opt_namespace_prefix(
         &mut self,
         node: Option<NamespacePrefix>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NamespacePrefix> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_namespace_prefix(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_namespace_prefix(&mut self.visitor, node)
         } else {
             node
         }
@@ -98834,23 +80217,18 @@ where
     fn fold_opt_nesting_selector(
         &mut self,
         node: Option<NestingSelector>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<NestingSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_nesting_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_nesting_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_number(
-        &mut self,
-        node: Option<Number>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Number> {
+    fn fold_opt_number(&mut self, node: Option<Number>) -> Option<Number> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_number(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_number(&mut self.visitor, node)
         } else {
             node
         }
@@ -98860,10 +80238,9 @@ where
     fn fold_opt_page_selector_pseudos(
         &mut self,
         node: Option<Vec<PageSelectorPseudo>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PageSelectorPseudo>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_page_selector_pseudos(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_page_selector_pseudos(&mut self.visitor, node)
         } else {
             node
         }
@@ -98873,10 +80250,9 @@ where
     fn fold_opt_page_selector_type(
         &mut self,
         node: Option<PageSelectorType>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<PageSelectorType> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_page_selector_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_page_selector_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -98886,14 +80262,9 @@ where
     fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoClassSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoClassSelectorChildren>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_opt_pseudo_class_selector_childrens(&mut self.visitor, node)
         } else {
             node
         }
@@ -98903,27 +80274,18 @@ where
     fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoElementSelectorChildren>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<PseudoElementSelectorChildren>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_opt_pseudo_element_selector_childrens(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_simple_block(
-        &mut self,
-        node: Option<SimpleBlock>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<SimpleBlock> {
+    fn fold_opt_simple_block(&mut self, node: Option<SimpleBlock>) -> Option<SimpleBlock> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_simple_block(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_simple_block(&mut self.visitor, node)
         } else {
             node
         }
@@ -98933,10 +80295,9 @@ where
     fn fold_opt_type_selector(
         &mut self,
         node: Option<Box<TypeSelector>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TypeSelector>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_type_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_type_selector(&mut self.visitor, node)
         } else {
             node
         }
@@ -98946,62 +80307,45 @@ where
     fn fold_opt_url_modifiers(
         &mut self,
         node: Option<Vec<UrlModifier>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<UrlModifier>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_url_modifiers(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_url_modifiers(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_url_value(
-        &mut self,
-        node: Option<Box<UrlValue>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<UrlValue>> {
+    fn fold_opt_url_value(&mut self, node: Option<Box<UrlValue>>) -> Option<Box<UrlValue>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_url_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_url_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_page_selector(
-        &mut self,
-        node: PageSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelector {
+    fn fold_page_selector(&mut self, node: PageSelector) -> PageSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_page_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_page_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_page_selector_list(
-        &mut self,
-        node: PageSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorList {
+    fn fold_page_selector_list(&mut self, node: PageSelectorList) -> PageSelectorList {
         if self.enabled {
-            <V as FoldAstPath>::fold_page_selector_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_page_selector_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_page_selector_pseudo(
-        &mut self,
-        node: PageSelectorPseudo,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorPseudo {
+    fn fold_page_selector_pseudo(&mut self, node: PageSelectorPseudo) -> PageSelectorPseudo {
         if self.enabled {
-            <V as FoldAstPath>::fold_page_selector_pseudo(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_page_selector_pseudo(&mut self.visitor, node)
         } else {
             node
         }
@@ -99011,58 +80355,45 @@ where
     fn fold_page_selector_pseudos(
         &mut self,
         node: Vec<PageSelectorPseudo>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PageSelectorPseudo> {
         if self.enabled {
-            <V as FoldAstPath>::fold_page_selector_pseudos(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_page_selector_pseudos(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_page_selector_type(
-        &mut self,
-        node: PageSelectorType,
-        __ast_path: &mut AstKindPath,
-    ) -> PageSelectorType {
+    fn fold_page_selector_type(&mut self, node: PageSelectorType) -> PageSelectorType {
         if self.enabled {
-            <V as FoldAstPath>::fold_page_selector_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_page_selector_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_page_selectors(
-        &mut self,
-        node: Vec<PageSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PageSelector> {
+    fn fold_page_selectors(&mut self, node: Vec<PageSelector>) -> Vec<PageSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_page_selectors(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_page_selectors(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
+    fn fold_percentage(&mut self, node: Percentage) -> Percentage {
         if self.enabled {
-            <V as FoldAstPath>::fold_percentage(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_percentage(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_pseudo_class_selector(
-        &mut self,
-        node: PseudoClassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> PseudoClassSelector {
+    fn fold_pseudo_class_selector(&mut self, node: PseudoClassSelector) -> PseudoClassSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_pseudo_class_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_pseudo_class_selector(&mut self.visitor, node)
         } else {
             node
         }
@@ -99072,14 +80403,9 @@ where
     fn fold_pseudo_class_selector_children(
         &mut self,
         node: PseudoClassSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoClassSelectorChildren {
         if self.enabled {
-            <V as FoldAstPath>::fold_pseudo_class_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_pseudo_class_selector_children(&mut self.visitor, node)
         } else {
             node
         }
@@ -99089,14 +80415,9 @@ where
     fn fold_pseudo_class_selector_childrens(
         &mut self,
         node: Vec<PseudoClassSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoClassSelectorChildren> {
         if self.enabled {
-            <V as FoldAstPath>::fold_pseudo_class_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_pseudo_class_selector_childrens(&mut self.visitor, node)
         } else {
             node
         }
@@ -99106,10 +80427,9 @@ where
     fn fold_pseudo_element_selector(
         &mut self,
         node: PseudoElementSelector,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_pseudo_element_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_pseudo_element_selector(&mut self.visitor, node)
         } else {
             node
         }
@@ -99119,14 +80439,9 @@ where
     fn fold_pseudo_element_selector_children(
         &mut self,
         node: PseudoElementSelectorChildren,
-        __ast_path: &mut AstKindPath,
     ) -> PseudoElementSelectorChildren {
         if self.enabled {
-            <V as FoldAstPath>::fold_pseudo_element_selector_children(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_pseudo_element_selector_children(&mut self.visitor, node)
         } else {
             node
         }
@@ -99136,150 +80451,117 @@ where
     fn fold_pseudo_element_selector_childrens(
         &mut self,
         node: Vec<PseudoElementSelectorChildren>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<PseudoElementSelectorChildren> {
         if self.enabled {
-            <V as FoldAstPath>::fold_pseudo_element_selector_childrens(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_pseudo_element_selector_childrens(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_qualified_rule(
-        &mut self,
-        node: QualifiedRule,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRule {
+    fn fold_qualified_rule(&mut self, node: QualifiedRule) -> QualifiedRule {
         if self.enabled {
-            <V as FoldAstPath>::fold_qualified_rule(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_qualified_rule(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_qualified_rule_prelude(
-        &mut self,
-        node: QualifiedRulePrelude,
-        __ast_path: &mut AstKindPath,
-    ) -> QualifiedRulePrelude {
+    fn fold_qualified_rule_prelude(&mut self, node: QualifiedRulePrelude) -> QualifiedRulePrelude {
         if self.enabled {
-            <V as FoldAstPath>::fold_qualified_rule_prelude(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_qualified_rule_prelude(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_query_in_parens(
-        &mut self,
-        node: QueryInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> QueryInParens {
+    fn fold_query_in_parens(&mut self, node: QueryInParens) -> QueryInParens {
         if self.enabled {
-            <V as FoldAstPath>::fold_query_in_parens(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_query_in_parens(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
+    fn fold_ratio(&mut self, node: Ratio) -> Ratio {
         if self.enabled {
-            <V as FoldAstPath>::fold_ratio(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ratio(&mut self.visitor, node)
         } else {
             node
         }
     }
-
-    #[inline]
-    fn fold_relative_selector(
-        &mut self,
-        node: RelativeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelector {
+
+    #[inline]
+    fn fold_relative_selector(&mut self, node: RelativeSelector) -> RelativeSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_relative_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_relative_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_relative_selector_list(
-        &mut self,
-        node: RelativeSelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> RelativeSelectorList {
+    fn fold_relative_selector_list(&mut self, node: RelativeSelectorList) -> RelativeSelectorList {
         if self.enabled {
-            <V as FoldAstPath>::fold_relative_selector_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_relative_selector_list(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_relative_selectors(
-        &mut self,
-        node: Vec<RelativeSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<RelativeSelector> {
+    fn fold_relative_selectors(&mut self, node: Vec<RelativeSelector>) -> Vec<RelativeSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_relative_selectors(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_relative_selectors(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
+    fn fold_resolution(&mut self, node: Resolution) -> Resolution {
         if self.enabled {
-            <V as FoldAstPath>::fold_resolution(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_resolution(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
+    fn fold_rule(&mut self, node: Rule) -> Rule {
         if self.enabled {
-            <V as FoldAstPath>::fold_rule(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_rule(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
+    fn fold_rules(&mut self, node: Vec<Rule>) -> Vec<Rule> {
         if self.enabled {
-            <V as FoldAstPath>::fold_rules(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_rules(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
+    fn fold_scope_range(&mut self, node: ScopeRange) -> ScopeRange {
         if self.enabled {
-            <V as FoldAstPath>::fold_scope_range(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_scope_range(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_selector_list(
-        &mut self,
-        node: SelectorList,
-        __ast_path: &mut AstKindPath,
-    ) -> SelectorList {
+    fn fold_selector_list(&mut self, node: SelectorList) -> SelectorList {
         if self.enabled {
-            <V as FoldAstPath>::fold_selector_list(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_selector_list(&mut self.visitor, node)
         } else {
             node
         }
@@ -99289,88 +80571,63 @@ where
     fn fold_sequence_of_custom_idents(
         &mut self,
         node: SequenceOfCustomIdents,
-        __ast_path: &mut AstKindPath,
     ) -> SequenceOfCustomIdents {
         if self.enabled {
-            <V as FoldAstPath>::fold_sequence_of_custom_idents(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_sequence_of_custom_idents(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_simple_block(
-        &mut self,
-        node: SimpleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleBlock {
+    fn fold_simple_block(&mut self, node: SimpleBlock) -> SimpleBlock {
         if self.enabled {
-            <V as FoldAstPath>::fold_simple_block(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_simple_block(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_size_feature(
-        &mut self,
-        node: SizeFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeature {
+    fn fold_size_feature(&mut self, node: SizeFeature) -> SizeFeature {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_size_feature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_size_feature_boolean(
-        &mut self,
-        node: SizeFeatureBoolean,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureBoolean {
+    fn fold_size_feature_boolean(&mut self, node: SizeFeatureBoolean) -> SizeFeatureBoolean {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature_boolean(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_size_feature_boolean(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_size_feature_name(
-        &mut self,
-        node: SizeFeatureName,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureName {
+    fn fold_size_feature_name(&mut self, node: SizeFeatureName) -> SizeFeatureName {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_size_feature_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_size_feature_plain(
-        &mut self,
-        node: SizeFeaturePlain,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeaturePlain {
+    fn fold_size_feature_plain(&mut self, node: SizeFeaturePlain) -> SizeFeaturePlain {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature_plain(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_size_feature_plain(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_size_feature_range(
-        &mut self,
-        node: SizeFeatureRange,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureRange {
+    fn fold_size_feature_range(&mut self, node: SizeFeatureRange) -> SizeFeatureRange {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature_range(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_size_feature_range(&mut self.visitor, node)
         } else {
             node
         }
@@ -99380,14 +80637,9 @@ where
     fn fold_size_feature_range_comparison(
         &mut self,
         node: SizeFeatureRangeComparison,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeComparison {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature_range_comparison(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_size_feature_range_comparison(&mut self.visitor, node)
         } else {
             node
         }
@@ -99397,119 +80649,90 @@ where
     fn fold_size_feature_range_interval(
         &mut self,
         node: SizeFeatureRangeInterval,
-        __ast_path: &mut AstKindPath,
     ) -> SizeFeatureRangeInterval {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature_range_interval(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_size_feature_range_interval(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_size_feature_value(
-        &mut self,
-        node: SizeFeatureValue,
-        __ast_path: &mut AstKindPath,
-    ) -> SizeFeatureValue {
+    fn fold_size_feature_value(&mut self, node: SizeFeatureValue) -> SizeFeatureValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_size_feature_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_size_feature_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
         if self.enabled {
-            <V as FoldAstPath>::fold_span(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_span(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+    fn fold_str(&mut self, node: Str) -> Str {
         if self.enabled {
-            <V as FoldAstPath>::fold_str(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_str(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
+    fn fold_style_block(&mut self, node: StyleBlock) -> StyleBlock {
         if self.enabled {
-            <V as FoldAstPath>::fold_style_block(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_style_block(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
+    fn fold_stylesheet(&mut self, node: Stylesheet) -> Stylesheet {
         if self.enabled {
-            <V as FoldAstPath>::fold_stylesheet(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_stylesheet(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_subclass_selector(
-        &mut self,
-        node: SubclassSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> SubclassSelector {
+    fn fold_subclass_selector(&mut self, node: SubclassSelector) -> SubclassSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_subclass_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_subclass_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_subclass_selectors(
-        &mut self,
-        node: Vec<SubclassSelector>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SubclassSelector> {
+    fn fold_subclass_selectors(&mut self, node: Vec<SubclassSelector>) -> Vec<SubclassSelector> {
         if self.enabled {
-            <V as FoldAstPath>::fold_subclass_selectors(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_subclass_selectors(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_supports_and(
-        &mut self,
-        node: SupportsAnd,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsAnd {
+    fn fold_supports_and(&mut self, node: SupportsAnd) -> SupportsAnd {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_and(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_and(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_supports_condition(
-        &mut self,
-        node: SupportsCondition,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsCondition {
+    fn fold_supports_condition(&mut self, node: SupportsCondition) -> SupportsCondition {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_condition(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_condition(&mut self.visitor, node)
         } else {
             node
         }
@@ -99519,10 +80742,9 @@ where
     fn fold_supports_condition_type(
         &mut self,
         node: SupportsConditionType,
-        __ast_path: &mut AstKindPath,
     ) -> SupportsConditionType {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_condition_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_condition_type(&mut self.visitor, node)
         } else {
             node
         }
@@ -99532,384 +80754,269 @@ where
     fn fold_supports_condition_types(
         &mut self,
         node: Vec<SupportsConditionType>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<SupportsConditionType> {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_condition_types(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_condition_types(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_supports_feature(
-        &mut self,
-        node: SupportsFeature,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsFeature {
+    fn fold_supports_feature(&mut self, node: SupportsFeature) -> SupportsFeature {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_feature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_feature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_supports_in_parens(
-        &mut self,
-        node: SupportsInParens,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsInParens {
+    fn fold_supports_in_parens(&mut self, node: SupportsInParens) -> SupportsInParens {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_in_parens(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_in_parens(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_supports_not(
-        &mut self,
-        node: SupportsNot,
-        __ast_path: &mut AstKindPath,
-    ) -> SupportsNot {
+    fn fold_supports_not(&mut self, node: SupportsNot) -> SupportsNot {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_not(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_not(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
+    fn fold_supports_or(&mut self, node: SupportsOr) -> SupportsOr {
         if self.enabled {
-            <V as FoldAstPath>::fold_supports_or(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_supports_or(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_tag_name_selector(
-        &mut self,
-        node: TagNameSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TagNameSelector {
+    fn fold_tag_name_selector(&mut self, node: TagNameSelector) -> TagNameSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_tag_name_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_tag_name_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
+    fn fold_time(&mut self, node: Time) -> Time {
         if self.enabled {
-            <V as FoldAstPath>::fold_time(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_time(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_time_percentage(
-        &mut self,
-        node: TimePercentage,
-        __ast_path: &mut AstKindPath,
-    ) -> TimePercentage {
+    fn fold_time_percentage(&mut self, node: TimePercentage) -> TimePercentage {
         if self.enabled {
-            <V as FoldAstPath>::fold_time_percentage(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_time_percentage(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
+    fn fold_token(&mut self, node: Token) -> Token {
         if self.enabled {
-            <V as FoldAstPath>::fold_token(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_token(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_token_and_span(
-        &mut self,
-        node: TokenAndSpan,
-        __ast_path: &mut AstKindPath,
-    ) -> TokenAndSpan {
+    fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
         if self.enabled {
-            <V as FoldAstPath>::fold_token_and_span(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_token_and_span(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_type_selector(
-        &mut self,
-        node: TypeSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> TypeSelector {
+    fn fold_type_selector(&mut self, node: TypeSelector) -> TypeSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_type_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_type_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_unicode_range(
-        &mut self,
-        node: UnicodeRange,
-        __ast_path: &mut AstKindPath,
-    ) -> UnicodeRange {
+    fn fold_unicode_range(&mut self, node: UnicodeRange) -> UnicodeRange {
         if self.enabled {
-            <V as FoldAstPath>::fold_unicode_range(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_unicode_range(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_universal_selector(
-        &mut self,
-        node: UniversalSelector,
-        __ast_path: &mut AstKindPath,
-    ) -> UniversalSelector {
+    fn fold_universal_selector(&mut self, node: UniversalSelector) -> UniversalSelector {
         if self.enabled {
-            <V as FoldAstPath>::fold_universal_selector(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_universal_selector(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_unknown_dimension(
-        &mut self,
-        node: UnknownDimension,
-        __ast_path: &mut AstKindPath,
-    ) -> UnknownDimension {
+    fn fold_unknown_dimension(&mut self, node: UnknownDimension) -> UnknownDimension {
         if self.enabled {
-            <V as FoldAstPath>::fold_unknown_dimension(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_unknown_dimension(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
+    fn fold_url(&mut self, node: Url) -> Url {
         if self.enabled {
-            <V as FoldAstPath>::fold_url(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_url(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_url_key_value(
-        &mut self,
-        node: UrlKeyValue,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlKeyValue {
+    fn fold_url_key_value(&mut self, node: UrlKeyValue) -> UrlKeyValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_url_key_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_url_key_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_url_modifier(
-        &mut self,
-        node: UrlModifier,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlModifier {
+    fn fold_url_modifier(&mut self, node: UrlModifier) -> UrlModifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_url_modifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_url_modifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_url_modifiers(
-        &mut self,
-        node: Vec<UrlModifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<UrlModifier> {
+    fn fold_url_modifiers(&mut self, node: Vec<UrlModifier>) -> Vec<UrlModifier> {
         if self.enabled {
-            <V as FoldAstPath>::fold_url_modifiers(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_url_modifiers(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
+    fn fold_url_value(&mut self, node: UrlValue) -> UrlValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_url_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_url_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_url_value_raw(
-        &mut self,
-        node: UrlValueRaw,
-        __ast_path: &mut AstKindPath,
-    ) -> UrlValueRaw {
+    fn fold_url_value_raw(&mut self, node: UrlValueRaw) -> UrlValueRaw {
         if self.enabled {
-            <V as FoldAstPath>::fold_url_value_raw(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_url_value_raw(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
+    fn fold_wq_name(&mut self, node: WqName) -> WqName {
         if self.enabled {
-            <V as FoldAstPath>::fold_wq_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_wq_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait FoldWithAstPath<V: ?Sized + FoldAstPath> {
+pub trait FoldWith<V: ?Sized + Fold> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
+    fn fold_with(self, visitor: &mut V) -> Self;
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
+    fn fold_children_with(self, visitor: &mut V) -> Self;
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AbsoluteColorBase {
-    #[doc = "Calls [FoldAstPath`::fold_absolute_color_base`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_absolute_color_base(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AbsoluteColorBase {
+    #[doc = "Calls [Fold`::fold_absolute_color_base`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_absolute_color_base(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AbsoluteColorBase::HexColor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
-                    self::fields::AbsoluteColorBaseField::HexColor,
-                ));
-                let _field_0 = <HexColor as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <HexColor as FoldWith<V>>::fold_with(_field_0, visitor);
                 AbsoluteColorBase::HexColor { 0: _field_0 }
             }
             AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
-                    self::fields::AbsoluteColorBaseField::NamedColorOrTransparent,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 }
             }
             AbsoluteColorBase::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
-                    self::fields::AbsoluteColorBaseField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 AbsoluteColorBase::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AlphaValue {
-    #[doc = "Calls [FoldAstPath`::fold_alpha_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_alpha_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AlphaValue {
+    #[doc = "Calls [Fold`::fold_alpha_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_alpha_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AlphaValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
-                    self::fields::AlphaValueField::Number,
-                ));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 AlphaValue::Number { 0: _field_0 }
             }
             AlphaValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
-                    self::fields::AlphaValueField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
                 AlphaValue::Percentage { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnPlusB {
-    #[doc = "Calls [FoldAstPath`::fold_an_plus_b`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_an_plus_b(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AnPlusB {
+    #[doc = "Calls [Fold`::fold_an_plus_b`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_an_plus_b(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AnPlusB::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::AnPlusB(self::fields::AnPlusBField::Ident));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 AnPlusB::Ident { 0: _field_0 }
             }
             AnPlusB::AnPlusBNotation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusB(
-                    self::fields::AnPlusBField::AnPlusBNotation,
-                ));
-                let _field_0 = <AnPlusBNotation as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AnPlusBNotation as FoldWith<V>>::fold_with(_field_0, visitor);
                 AnPlusB::AnPlusBNotation { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnPlusBNotation {
-    #[doc = "Calls [FoldAstPath`::fold_an_plus_b_notation`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_an_plus_b_notation(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AnPlusBNotation {
+    #[doc = "Calls [Fold`::fold_an_plus_b_notation`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_an_plus_b_notation(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AnPlusBNotation {
                 span,
@@ -99918,36 +81025,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnPlusBNotation {
                 b,
                 b_raw,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
-                        self::fields::AnPlusBNotationField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let a_raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
-                        self::fields::AnPlusBNotationField::ARaw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        a_raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let b_raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
-                        self::fields::AnPlusBNotationField::BRaw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        b_raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let a_raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(a_raw, visitor) };
+                let b_raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(b_raw, visitor) };
                 AnPlusBNotation {
                     span,
                     a,
@@ -99959,119 +81039,64 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnPlusBNotation {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Angle {
-    #[doc = "Calls [FoldAstPath`::fold_angle`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_angle(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Angle {
+    #[doc = "Calls [Fold`::fold_angle`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_angle(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Angle { span, value, unit } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Angle(self::fields::AngleField::Value));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Unit));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
+                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
                 Angle { span, value, unit }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnglePercentage {
-    #[doc = "Calls [FoldAstPath`::fold_angle_percentage`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_angle_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AnglePercentage {
+    #[doc = "Calls [Fold`::fold_angle_percentage`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_angle_percentage(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AnglePercentage::Angle { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
-                    self::fields::AnglePercentageField::Angle,
-                ));
-                let _field_0 = <Angle as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Angle as FoldWith<V>>::fold_with(_field_0, visitor);
                 AnglePercentage::Angle { 0: _field_0 }
             }
             AnglePercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
-                    self::fields::AnglePercentageField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
                 AnglePercentage::Percentage { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnyNamespace {
-    #[doc = "Calls [FoldAstPath`::fold_any_namespace`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_any_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AnyNamespace {
+    #[doc = "Calls [Fold`::fold_any_namespace`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_any_namespace(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AnyNamespace { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnyNamespace(
-                        self::fields::AnyNamespaceField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 AnyNamespace { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRule {
-    #[doc = "Calls [FoldAstPath`::fold_at_rule`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_at_rule(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AtRule {
+    #[doc = "Calls [Fold`::fold_at_rule`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_at_rule(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AtRule {
                 span,
@@ -100079,42 +81104,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRule {
                 prelude,
                 block,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Name));
-                    <AtRuleName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prelude = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Prelude));
-                    <Option<Box<AtRulePrelude>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let block = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Block));
-                    <Option<SimpleBlock> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <AtRuleName as FoldWith<V>>::fold_with(name, visitor) };
+                let prelude =
+                    { <Option<Box<AtRulePrelude>> as FoldWith<V>>::fold_with(prelude, visitor) };
+                let block = { <Option<SimpleBlock> as FoldWith<V>>::fold_with(block, visitor) };
                 AtRule {
                     span,
                     name,
@@ -100125,272 +81119,120 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRule {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRuleName {
-    #[doc = "Calls [FoldAstPath`::fold_at_rule_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_at_rule_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AtRuleName {
+    #[doc = "Calls [Fold`::fold_at_rule_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_at_rule_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AtRuleName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
-                    self::fields::AtRuleNameField::DashedIdent,
-                ));
-                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRuleName::DashedIdent { 0: _field_0 }
             }
             AtRuleName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
-                    self::fields::AtRuleNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRuleName::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRulePrelude {
-    #[doc = "Calls [FoldAstPath`::fold_at_rule_prelude`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_at_rule_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AtRulePrelude {
+    #[doc = "Calls [Fold`::fold_at_rule_prelude`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_at_rule_prelude(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AtRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ListOfComponentValues,
-                ));
-                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::ListOfComponentValues { 0: _field_0 }
             }
             AtRulePrelude::CharsetPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::CharsetPrelude,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::CharsetPrelude { 0: _field_0 }
             }
             AtRulePrelude::PropertyPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::PropertyPrelude,
-                ));
-                let _field_0 = <CustomPropertyName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CustomPropertyName as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::PropertyPrelude { 0: _field_0 }
             }
             AtRulePrelude::CounterStylePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::CounterStylePrelude,
-                ));
-                let _field_0 = <CustomIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CustomIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::CounterStylePrelude { 0: _field_0 }
             }
             AtRulePrelude::ColorProfilePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ColorProfilePrelude,
-                ));
-                let _field_0 = <ColorProfileName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ColorProfileName as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::ColorProfilePrelude { 0: _field_0 }
             }
             AtRulePrelude::DocumentPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::DocumentPrelude,
-                ));
-                let _field_0 = <DocumentPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DocumentPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::DocumentPrelude { 0: _field_0 }
             }
             AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::FontPaletteValuesPrelude,
-                ));
-                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 }
             }
             AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::FontFeatureValuesPrelude,
-                ));
-                let _field_0 = <FontFeatureValuesPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <FontFeatureValuesPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 }
             }
             AtRulePrelude::NestPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::NestPrelude,
-                ));
-                let _field_0 = <SelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::NestPrelude { 0: _field_0 }
             }
             AtRulePrelude::KeyframesPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::KeyframesPrelude,
-                ));
-                let _field_0 = <KeyframesName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <KeyframesName as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::KeyframesPrelude { 0: _field_0 }
             }
             AtRulePrelude::ImportPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ImportPrelude,
-                ));
-                let _field_0 = <ImportPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ImportPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::ImportPrelude { 0: _field_0 }
             }
             AtRulePrelude::NamespacePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::NamespacePrelude,
-                ));
-                let _field_0 = <NamespacePrelude as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <NamespacePrelude as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::NamespacePrelude { 0: _field_0 }
             }
             AtRulePrelude::MediaPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::MediaPrelude,
-                ));
-                let _field_0 = <MediaQueryList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaQueryList as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::MediaPrelude { 0: _field_0 }
             }
             AtRulePrelude::SupportsPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::SupportsPrelude,
-                ));
-                let _field_0 = <SupportsCondition as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SupportsCondition as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::SupportsPrelude { 0: _field_0 }
             }
             AtRulePrelude::PagePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::PagePrelude,
-                ));
-                let _field_0 = <PageSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PageSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::PagePrelude { 0: _field_0 }
             }
             AtRulePrelude::LayerPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::LayerPrelude,
-                ));
-                let _field_0 = <LayerPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <LayerPrelude as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::LayerPrelude { 0: _field_0 }
             }
             AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ContainerPrelude,
-                ));
-                let _field_0 = <ContainerCondition as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ContainerCondition as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::ContainerPrelude { 0: _field_0 }
             }
             AtRulePrelude::CustomMediaPrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::CustomMediaPrelude,
-                ));
-                let _field_0 = <CustomMediaQuery as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CustomMediaQuery as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::CustomMediaPrelude { 0: _field_0 }
             }
             AtRulePrelude::ScopePrelude { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
-                    self::fields::AtRulePreludeField::ScopePrelude,
-                ));
-                let _field_0 = <ScopeRange as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ScopeRange as FoldWith<V>>::fold_with(_field_0, visitor);
                 AtRulePrelude::ScopePrelude { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelector {
-    #[doc = "Calls [FoldAstPath`::fold_attribute_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_attribute_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelector {
+    #[doc = "Calls [Fold`::fold_attribute_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_attribute_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AttributeSelector {
                 span,
@@ -100399,55 +81241,15 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelector {
                 value,
                 modifier,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Name,
-                    ));
-                    <WqName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <WqName as FoldWith<V>>::fold_with(name, visitor) };
                 let matcher = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Matcher,
-                    ));
-                    <Option<AttributeSelectorMatcher> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        matcher,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Value,
-                    ));
-                    <Option<AttributeSelectorValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<AttributeSelectorMatcher> as FoldWith<V>>::fold_with(matcher, visitor)
                 };
+                let value =
+                    { <Option<AttributeSelectorValue> as FoldWith<V>>::fold_with(value, visitor) };
                 let modifier = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
-                        self::fields::AttributeSelectorField::Modifier,
-                    ));
-                    <Option<AttributeSelectorModifier> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        modifier,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<AttributeSelectorModifier> as FoldWith<V>>::fold_with(modifier, visitor)
                 };
                 AttributeSelector {
                     span,
@@ -100460,53 +81262,30 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelector {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorMatcher {
-    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_matcher`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_attribute_selector_matcher(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorMatcher {
+    #[doc = "Calls [Fold`::fold_attribute_selector_matcher`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_attribute_selector_matcher(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AttributeSelectorMatcher { span, value } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
-                            self::fields::AttributeSelectorMatcherField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
-                            self::fields::AttributeSelectorMatcherField::Value,
-                        ));
-                    <AttributeSelectorMatcherValue as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value =
+                    { <AttributeSelectorMatcherValue as FoldWith<V>>::fold_with(value, visitor) };
                 AttributeSelectorMatcher { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorMatcherValue {
-    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_matcher_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_attribute_selector_matcher_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorMatcherValue {
+    #[doc = "Calls [Fold`::fold_attribute_selector_matcher_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_attribute_selector_matcher_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AttributeSelectorMatcherValue::Equals => AttributeSelectorMatcherValue::Equals,
             AttributeSelectorMatcherValue::Tilde => AttributeSelectorMatcherValue::Tilde,
@@ -100517,88 +81296,48 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorMatcherVal
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorModifier {
-    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_modifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_attribute_selector_modifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorModifier {
+    #[doc = "Calls [Fold`::fold_attribute_selector_modifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_attribute_selector_modifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AttributeSelectorModifier { span, value } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
-                            self::fields::AttributeSelectorModifierField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
-                            self::fields::AttributeSelectorModifierField::Value,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
                 AttributeSelectorModifier { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorValue {
-    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_attribute_selector_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AttributeSelectorValue {
+    #[doc = "Calls [Fold`::fold_attribute_selector_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_attribute_selector_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AttributeSelectorValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
-                    self::fields::AttributeSelectorValueField::Str,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 AttributeSelectorValue::Str { 0: _field_0 }
             }
             AttributeSelectorValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
-                    self::fields::AttributeSelectorValueField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 AttributeSelectorValue::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinOp {
-    #[doc = "Calls [FoldAstPath`::fold_bin_op`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_bin_op(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BinOp {
+    #[doc = "Calls [Fold`::fold_bin_op`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_bin_op(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BinOp::Add => BinOp::Add,
             BinOp::Sub => BinOp::Sub,
@@ -100607,51 +81346,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcOperator {
-    #[doc = "Calls [FoldAstPath`::fold_calc_operator`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CalcOperator {
+    #[doc = "Calls [Fold`::fold_calc_operator`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_operator(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CalcOperator { span, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
-                        self::fields::CalcOperatorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
-                        self::fields::CalcOperatorField::Value,
-                    ));
-                    <CalcOperatorType as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <CalcOperatorType as FoldWith<V>>::fold_with(value, visitor) };
                 CalcOperator { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcOperatorType {
-    #[doc = "Calls [FoldAstPath`::fold_calc_operator_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_operator_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CalcOperatorType {
+    #[doc = "Calls [Fold`::fold_calc_operator_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_operator_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CalcOperatorType::Add => CalcOperatorType::Add,
             CalcOperatorType::Sub => CalcOperatorType::Sub,
@@ -100660,432 +81377,218 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcOperatorType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcProduct {
-    #[doc = "Calls [FoldAstPath`::fold_calc_product`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_product(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CalcProduct {
+    #[doc = "Calls [Fold`::fold_calc_product`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_product(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CalcProduct { span, expressions } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
-                        self::fields::CalcProductField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expressions = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
-                        self::fields::CalcProductField::Expressions(usize::MAX),
-                    ));
-                    <Vec<CalcValueOrOperator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expressions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expressions =
+                    { <Vec<CalcValueOrOperator> as FoldWith<V>>::fold_with(expressions, visitor) };
                 CalcProduct { span, expressions }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcProductOrOperator {
-    #[doc = "Calls [FoldAstPath`::fold_calc_product_or_operator`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_product_or_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CalcProductOrOperator {
+    #[doc = "Calls [Fold`::fold_calc_product_or_operator`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_product_or_operator(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CalcProductOrOperator::Product { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
-                    self::fields::CalcProductOrOperatorField::Product,
-                ));
-                let _field_0 = <CalcProduct as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CalcProduct as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcProductOrOperator::Product { 0: _field_0 }
             }
             CalcProductOrOperator::Operator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
-                    self::fields::CalcProductOrOperatorField::Operator,
-                ));
-                let _field_0 = <CalcOperator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CalcOperator as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcProductOrOperator::Operator { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcSum {
-    #[doc = "Calls [FoldAstPath`::fold_calc_sum`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_sum(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CalcSum {
+    #[doc = "Calls [Fold`::fold_calc_sum`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_sum(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CalcSum { span, expressions } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CalcSum(self::fields::CalcSumField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 let expressions = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcSum(
-                        self::fields::CalcSumField::Expressions(usize::MAX),
-                    ));
-                    <Vec<CalcProductOrOperator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expressions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<CalcProductOrOperator> as FoldWith<V>>::fold_with(expressions, visitor)
                 };
                 CalcSum { span, expressions }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcValue {
-    #[doc = "Calls [FoldAstPath`::fold_calc_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CalcValue {
+    #[doc = "Calls [Fold`::fold_calc_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CalcValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Number,
-                ));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValue::Number { 0: _field_0 }
             }
             CalcValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Dimension,
-                ));
-                let _field_0 = <Dimension as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Dimension as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValue::Dimension { 0: _field_0 }
             }
             CalcValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValue::Percentage { 0: _field_0 }
             }
             CalcValue::Constant { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Constant,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValue::Constant { 0: _field_0 }
             }
             CalcValue::Sum { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::CalcValue(self::fields::CalcValueField::Sum));
-                let _field_0 = <CalcSum as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CalcSum as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValue::Sum { 0: _field_0 }
             }
             CalcValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
-                    self::fields::CalcValueField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValue::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcValueOrOperator {
-    #[doc = "Calls [FoldAstPath`::fold_calc_value_or_operator`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_value_or_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CalcValueOrOperator {
+    #[doc = "Calls [Fold`::fold_calc_value_or_operator`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_value_or_operator(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CalcValueOrOperator::Value { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
-                    self::fields::CalcValueOrOperatorField::Value,
-                ));
-                let _field_0 = <CalcValue as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CalcValue as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValueOrOperator::Value { 0: _field_0 }
             }
             CalcValueOrOperator::Operator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
-                    self::fields::CalcValueOrOperatorField::Operator,
-                ));
-                let _field_0 = <CalcOperator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CalcOperator as FoldWith<V>>::fold_with(_field_0, visitor);
                 CalcValueOrOperator::Operator { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassSelector {
-    #[doc = "Calls [FoldAstPath`::fold_class_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ClassSelector {
+    #[doc = "Calls [Fold`::fold_class_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ClassSelector { span, text } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
-                        self::fields::ClassSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let text = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
-                        self::fields::ClassSelectorField::Text,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        text,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let text = { <Ident as FoldWith<V>>::fold_with(text, visitor) };
                 ClassSelector { span, text }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CmykComponent {
-    #[doc = "Calls [FoldAstPath`::fold_cmyk_component`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_cmyk_component(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CmykComponent {
+    #[doc = "Calls [Fold`::fold_cmyk_component`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_cmyk_component(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CmykComponent::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
-                    self::fields::CmykComponentField::Number,
-                ));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 CmykComponent::Number { 0: _field_0 }
             }
             CmykComponent::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
-                    self::fields::CmykComponentField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
                 CmykComponent::Percentage { 0: _field_0 }
             }
             CmykComponent::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
-                    self::fields::CmykComponentField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 CmykComponent::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Color {
-    #[doc = "Calls [FoldAstPath`::fold_color`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_color(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Color {
+    #[doc = "Calls [Fold`::fold_color`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_color(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Color::AbsoluteColorBase { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
-                    self::fields::ColorField::AbsoluteColorBase,
-                ));
-                let _field_0 = <AbsoluteColorBase as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AbsoluteColorBase as FoldWith<V>>::fold_with(_field_0, visitor);
                 Color::AbsoluteColorBase { 0: _field_0 }
             }
             Color::CurrentColorOrSystemColor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
-                    self::fields::ColorField::CurrentColorOrSystemColor,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 Color::CurrentColorOrSystemColor { 0: _field_0 }
             }
             Color::Function { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Color(self::fields::ColorField::Function));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 Color::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ColorProfileName {
-    #[doc = "Calls [FoldAstPath`::fold_color_profile_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_color_profile_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ColorProfileName {
+    #[doc = "Calls [Fold`::fold_color_profile_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_color_profile_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ColorProfileName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
-                    self::fields::ColorProfileNameField::DashedIdent,
-                ));
-                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 ColorProfileName::DashedIdent { 0: _field_0 }
             }
             ColorProfileName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
-                    self::fields::ColorProfileNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 ColorProfileName::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Combinator {
-    #[doc = "Calls [FoldAstPath`::fold_combinator`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_combinator(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Combinator {
+    #[doc = "Calls [Fold`::fold_combinator`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_combinator(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Combinator { span, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
-                        self::fields::CombinatorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
-                        self::fields::CombinatorField::Value,
-                    ));
-                    <CombinatorValue as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <CombinatorValue as FoldWith<V>>::fold_with(value, visitor) };
                 Combinator { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CombinatorValue {
-    #[doc = "Calls [FoldAstPath`::fold_combinator_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_combinator_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CombinatorValue {
+    #[doc = "Calls [Fold`::fold_combinator_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_combinator_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CombinatorValue::Descendant => CombinatorValue::Descendant,
             CombinatorValue::NextSibling => CombinatorValue::NextSibling,
@@ -101095,452 +81598,191 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CombinatorValue {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComplexSelector {
-    #[doc = "Calls [FoldAstPath`::fold_complex_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_complex_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ComplexSelector {
+    #[doc = "Calls [Fold`::fold_complex_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_complex_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ComplexSelector { span, children } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
-                        self::fields::ComplexSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let children = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
-                        self::fields::ComplexSelectorField::Children(usize::MAX),
-                    ));
-                    <Vec<ComplexSelectorChildren> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let children =
+                    { <Vec<ComplexSelectorChildren> as FoldWith<V>>::fold_with(children, visitor) };
                 ComplexSelector { span, children }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComplexSelectorChildren {
-    #[doc = "Calls [FoldAstPath`::fold_complex_selector_children`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_complex_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ComplexSelectorChildren {
+    #[doc = "Calls [Fold`::fold_complex_selector_children`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_complex_selector_children(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ComplexSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
-                    self::fields::ComplexSelectorChildrenField::CompoundSelector,
-                ));
-                let _field_0 = <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CompoundSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComplexSelectorChildren::CompoundSelector { 0: _field_0 }
             }
             ComplexSelectorChildren::Combinator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
-                    self::fields::ComplexSelectorChildrenField::Combinator,
-                ));
-                let _field_0 = <Combinator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Combinator as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComplexSelectorChildren::Combinator { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComponentValue {
-    #[doc = "Calls [FoldAstPath`::fold_component_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_component_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ComponentValue {
+    #[doc = "Calls [Fold`::fold_component_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_component_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ComponentValue::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::PreservedToken,
-                ));
-                let _field_0 = <Box<TokenAndSpan> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TokenAndSpan> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::PreservedToken { 0: _field_0 }
-            }
-            ComponentValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Function,
-                ));
-                let _field_0 = <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+            }
+            ComponentValue::Function { 0: _field_0 } => {
+                let _field_0 = <Box<Function> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Function { 0: _field_0 }
             }
             ComponentValue::SimpleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::SimpleBlock,
-                ));
-                let _field_0 = <Box<SimpleBlock> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<SimpleBlock> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::SimpleBlock { 0: _field_0 }
             }
             ComponentValue::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::AtRule,
-                ));
-                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::AtRule { 0: _field_0 }
             }
             ComponentValue::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::QualifiedRule,
-                ));
-                let _field_0 = <Box<QualifiedRule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<QualifiedRule> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::QualifiedRule { 0: _field_0 }
             }
             ComponentValue::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::ListOfComponentValues,
-                ));
                 let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::ListOfComponentValues { 0: _field_0 }
             }
             ComponentValue::KeyframeBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::KeyframeBlock,
-                ));
-                let _field_0 = <Box<KeyframeBlock> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<KeyframeBlock> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::KeyframeBlock { 0: _field_0 }
             }
             ComponentValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Ident,
-                ));
-                let _field_0 = <Box<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Ident> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Ident { 0: _field_0 }
             }
             ComponentValue::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::DashedIdent,
-                ));
-                let _field_0 = <Box<DashedIdent> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<DashedIdent> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::DashedIdent { 0: _field_0 }
             }
             ComponentValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Str,
-                ));
-                let _field_0 = <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Str> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Str { 0: _field_0 }
             }
             ComponentValue::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Url,
-                ));
-                let _field_0 = <Box<Url> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Url> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Url { 0: _field_0 }
             }
             ComponentValue::Integer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Integer,
-                ));
-                let _field_0 = <Box<Integer> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Integer> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Integer { 0: _field_0 }
             }
             ComponentValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Number,
-                ));
-                let _field_0 = <Box<Number> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Number> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Number { 0: _field_0 }
             }
             ComponentValue::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Percentage,
-                ));
-                let _field_0 = <Box<Percentage> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Percentage> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Percentage { 0: _field_0 }
             }
             ComponentValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Dimension,
-                ));
-                let _field_0 = <Box<Dimension> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Dimension> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Dimension { 0: _field_0 }
             }
             ComponentValue::LengthPercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::LengthPercentage,
-                ));
-                let _field_0 = <Box<LengthPercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<LengthPercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::LengthPercentage { 0: _field_0 }
             }
             ComponentValue::FrequencyPercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::FrequencyPercentage,
-                ));
-                let _field_0 = <Box<FrequencyPercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <Box<FrequencyPercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::FrequencyPercentage { 0: _field_0 }
             }
             ComponentValue::AnglePercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::AnglePercentage,
-                ));
-                let _field_0 = <Box<AnglePercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<AnglePercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::AnglePercentage { 0: _field_0 }
             }
             ComponentValue::TimePercentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::TimePercentage,
-                ));
-                let _field_0 = <Box<TimePercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TimePercentage> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::TimePercentage { 0: _field_0 }
             }
             ComponentValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Ratio,
-                ));
-                let _field_0 = <Box<Ratio> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Ratio> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Ratio { 0: _field_0 }
             }
             ComponentValue::UnicodeRange { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::UnicodeRange,
-                ));
-                let _field_0 = <Box<UnicodeRange> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<UnicodeRange> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::UnicodeRange { 0: _field_0 }
             }
             ComponentValue::Color { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Color,
-                ));
-                let _field_0 = <Box<Color> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Color> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Color { 0: _field_0 }
             }
             ComponentValue::AlphaValue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::AlphaValue,
-                ));
-                let _field_0 = <Box<AlphaValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<AlphaValue> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::AlphaValue { 0: _field_0 }
             }
             ComponentValue::Hue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Hue,
-                ));
-                let _field_0 = <Box<Hue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Hue> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Hue { 0: _field_0 }
             }
             ComponentValue::CmykComponent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::CmykComponent,
-                ));
-                let _field_0 = <Box<CmykComponent> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<CmykComponent> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::CmykComponent { 0: _field_0 }
             }
             ComponentValue::Delimiter { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Delimiter,
-                ));
-                let _field_0 = <Box<Delimiter> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Delimiter> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Delimiter { 0: _field_0 }
             }
             ComponentValue::CalcSum { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::CalcSum,
-                ));
-                let _field_0 = <Box<CalcSum> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<CalcSum> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::CalcSum { 0: _field_0 }
             }
             ComponentValue::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::ComplexSelector,
-                ));
-                let _field_0 = <Box<ComplexSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<ComplexSelector> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::ComplexSelector { 0: _field_0 }
             }
             ComponentValue::LayerName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::LayerName,
-                ));
-                let _field_0 = <Box<LayerName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<LayerName> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::LayerName { 0: _field_0 }
             }
             ComponentValue::SupportsCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::SupportsCondition,
-                ));
-                let _field_0 = <Box<SupportsCondition> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <Box<SupportsCondition> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::SupportsCondition { 0: _field_0 }
             }
             ComponentValue::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::Declaration,
-                ));
-                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::Declaration { 0: _field_0 }
             }
             ComponentValue::IdSelector { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
-                    self::fields::ComponentValueField::IdSelector,
-                ));
-                let _field_0 = <Box<IdSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<IdSelector> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ComponentValue::IdSelector { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CompoundSelector {
-    #[doc = "Calls [FoldAstPath`::fold_compound_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_compound_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CompoundSelector {
+    #[doc = "Calls [Fold`::fold_compound_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_compound_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CompoundSelector {
                 span,
@@ -101548,45 +81790,15 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CompoundSelector {
                 type_selector,
                 subclass_selectors,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 let nesting_selector = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::NestingSelector,
-                    ));
-                    <Option<NestingSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        nesting_selector,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<NestingSelector> as FoldWith<V>>::fold_with(nesting_selector, visitor)
                 };
                 let type_selector = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::TypeSelector,
-                    ));
-                    <Option<Box<TypeSelector>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_selector,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TypeSelector>> as FoldWith<V>>::fold_with(type_selector, visitor)
                 };
                 let subclass_selectors = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
-                        self::fields::CompoundSelectorField::SubclassSelectors(usize::MAX),
-                    ));
-                    <Vec<SubclassSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        subclass_selectors,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<SubclassSelector> as FoldWith<V>>::fold_with(subclass_selectors, visitor)
                 };
                 CompoundSelector {
                     span,
@@ -101598,195 +81810,88 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CompoundSelector {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CompoundSelectorList {
-    #[doc = "Calls [FoldAstPath`::fold_compound_selector_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_compound_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CompoundSelectorList {
+    #[doc = "Calls [Fold`::fold_compound_selector_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_compound_selector_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CompoundSelectorList { span, children } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
-                            self::fields::CompoundSelectorListField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let children = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
-                            self::fields::CompoundSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<CompoundSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let children =
+                    { <Vec<CompoundSelector> as FoldWith<V>>::fold_with(children, visitor) };
                 CompoundSelectorList { span, children }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerCondition {
-    #[doc = "Calls [FoldAstPath`::fold_container_condition`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_condition(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ContainerCondition {
+    #[doc = "Calls [Fold`::fold_container_condition`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_condition(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ContainerCondition { span, name, query } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
-                        self::fields::ContainerConditionField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
-                        self::fields::ContainerConditionField::Name,
-                    ));
-                    <Option<ContainerName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let query = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
-                        self::fields::ContainerConditionField::Query,
-                    ));
-                    <ContainerQuery as FoldWithAstPath<V>>::fold_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Option<ContainerName> as FoldWith<V>>::fold_with(name, visitor) };
+                let query = { <ContainerQuery as FoldWith<V>>::fold_with(query, visitor) };
                 ContainerCondition { span, name, query }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerName {
-    #[doc = "Calls [FoldAstPath`::fold_container_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ContainerName {
+    #[doc = "Calls [Fold`::fold_container_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ContainerName::CustomIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerName(
-                    self::fields::ContainerNameField::CustomIdent,
-                ));
-                let _field_0 = <CustomIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CustomIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 ContainerName::CustomIdent { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQuery {
-    #[doc = "Calls [FoldAstPath`::fold_container_query`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_query(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ContainerQuery {
+    #[doc = "Calls [Fold`::fold_container_query`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_query(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ContainerQuery { span, queries } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
-                        self::fields::ContainerQueryField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let queries = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
-                        self::fields::ContainerQueryField::Queries(usize::MAX),
-                    ));
-                    <Vec<ContainerQueryType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        queries,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                ContainerQuery { span, queries }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryAnd {
-    #[doc = "Calls [FoldAstPath`::fold_container_query_and`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_query_and(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            ContainerQueryAnd {
-                span,
-                keyword,
-                query,
-            } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
-                        self::fields::ContainerQueryAndField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
-                        self::fields::ContainerQueryAndField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let query = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
-                        self::fields::ContainerQueryAndField::Query,
-                    ));
-                    <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let queries =
+                    { <Vec<ContainerQueryType> as FoldWith<V>>::fold_with(queries, visitor) };
+                ContainerQuery { span, queries }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryAnd {
+    #[doc = "Calls [Fold`::fold_container_query_and`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_query_and(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            ContainerQueryAnd {
+                span,
+                keyword,
+                query,
+            } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let query = { <QueryInParens as FoldWith<V>>::fold_with(query, visitor) };
                 ContainerQueryAnd {
                     span,
                     keyword,
@@ -101796,51 +81901,22 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryAnd {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryNot {
-    #[doc = "Calls [FoldAstPath`::fold_container_query_not`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_query_not(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryNot {
+    #[doc = "Calls [Fold`::fold_container_query_not`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_query_not(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ContainerQueryNot {
                 span,
                 keyword,
                 query,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
-                        self::fields::ContainerQueryNotField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
-                        self::fields::ContainerQueryNotField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let query = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
-                        self::fields::ContainerQueryNotField::Query,
-                    ));
-                    <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let query = { <QueryInParens as FoldWith<V>>::fold_with(query, visitor) };
                 ContainerQueryNot {
                     span,
                     keyword,
@@ -101850,51 +81926,22 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryNot {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryOr {
-    #[doc = "Calls [FoldAstPath`::fold_container_query_or`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_query_or(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryOr {
+    #[doc = "Calls [Fold`::fold_container_query_or`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_query_or(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ContainerQueryOr {
                 span,
                 keyword,
                 query,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
-                        self::fields::ContainerQueryOrField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
-                        self::fields::ContainerQueryOrField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let query = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
-                        self::fields::ContainerQueryOrField::Query,
-                    ));
-                    <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                        query,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let query = { <QueryInParens as FoldWith<V>>::fold_with(query, visitor) };
                 ContainerQueryOr {
                     span,
                     keyword,
@@ -101904,339 +81951,145 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryOr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryType {
-    #[doc = "Calls [FoldAstPath`::fold_container_query_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_query_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ContainerQueryType {
+    #[doc = "Calls [Fold`::fold_container_query_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_query_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ContainerQueryType::Not { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::Not,
-                ));
-                let _field_0 = <ContainerQueryNot as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ContainerQueryNot as FoldWith<V>>::fold_with(_field_0, visitor);
                 ContainerQueryType::Not { 0: _field_0 }
             }
             ContainerQueryType::And { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::And,
-                ));
-                let _field_0 = <ContainerQueryAnd as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ContainerQueryAnd as FoldWith<V>>::fold_with(_field_0, visitor);
                 ContainerQueryType::And { 0: _field_0 }
             }
             ContainerQueryType::Or { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::Or,
-                ));
-                let _field_0 = <ContainerQueryOr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ContainerQueryOr as FoldWith<V>>::fold_with(_field_0, visitor);
                 ContainerQueryType::Or { 0: _field_0 }
             }
             ContainerQueryType::QueryInParens { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
-                    self::fields::ContainerQueryTypeField::QueryInParens,
-                ));
-                let _field_0 = <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <QueryInParens as FoldWith<V>>::fold_with(_field_0, visitor);
                 ContainerQueryType::QueryInParens { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomHighlightName {
-    #[doc = "Calls [FoldAstPath`::fold_custom_highlight_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_custom_highlight_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CustomHighlightName {
+    #[doc = "Calls [Fold`::fold_custom_highlight_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_custom_highlight_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CustomHighlightName { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
-                        self::fields::CustomHighlightNameField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
-                        self::fields::CustomHighlightNameField::Value,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
-                        self::fields::CustomHighlightNameField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 CustomHighlightName { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomIdent {
-    #[doc = "Calls [FoldAstPath`::fold_custom_ident`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_custom_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CustomIdent {
+    #[doc = "Calls [Fold`::fold_custom_ident`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_custom_ident(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CustomIdent { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
-                        self::fields::CustomIdentField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
-                        self::fields::CustomIdentField::Value,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
-                        self::fields::CustomIdentField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 CustomIdent { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomMediaQuery {
-    #[doc = "Calls [FoldAstPath`::fold_custom_media_query`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_custom_media_query(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CustomMediaQuery {
+    #[doc = "Calls [Fold`::fold_custom_media_query`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_custom_media_query(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CustomMediaQuery { span, name, media } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
-                        self::fields::CustomMediaQueryField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
-                        self::fields::CustomMediaQueryField::Name,
-                    ));
-                    <ExtensionName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let media = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
-                        self::fields::CustomMediaQueryField::Media,
-                    ));
-                    <CustomMediaQueryMediaType as FoldWithAstPath<V>>::fold_with_ast_path(
-                        media,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <ExtensionName as FoldWith<V>>::fold_with(name, visitor) };
+                let media =
+                    { <CustomMediaQueryMediaType as FoldWith<V>>::fold_with(media, visitor) };
                 CustomMediaQuery { span, name, media }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomMediaQueryMediaType {
-    #[doc = "Calls [FoldAstPath`::fold_custom_media_query_media_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_custom_media_query_media_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CustomMediaQueryMediaType {
+    #[doc = "Calls [Fold`::fold_custom_media_query_media_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_custom_media_query_media_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CustomMediaQueryMediaType::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
-                        self::fields::CustomMediaQueryMediaTypeField::Ident,
-                    ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 CustomMediaQueryMediaType::Ident { 0: _field_0 }
             }
             CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
-                        self::fields::CustomMediaQueryMediaTypeField::MediaQueryList,
-                    ));
-                let _field_0 = <MediaQueryList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaQueryList as FoldWith<V>>::fold_with(_field_0, visitor);
                 CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomPropertyName {
-    #[doc = "Calls [FoldAstPath`::fold_custom_property_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_custom_property_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CustomPropertyName {
+    #[doc = "Calls [Fold`::fold_custom_property_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_custom_property_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CustomPropertyName { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
-                        self::fields::CustomPropertyNameField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
-                        self::fields::CustomPropertyNameField::Value,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
-                        self::fields::CustomPropertyNameField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 CustomPropertyName { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DashedIdent {
-    #[doc = "Calls [FoldAstPath`::fold_dashed_ident`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_dashed_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DashedIdent {
+    #[doc = "Calls [Fold`::fold_dashed_ident`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_dashed_ident(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DashedIdent { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
-                        self::fields::DashedIdentField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
-                        self::fields::DashedIdentField::Value,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
-                        self::fields::DashedIdentField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 DashedIdent { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Declaration {
-    #[doc = "Calls [FoldAstPath`::fold_declaration`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_declaration(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Declaration {
+    #[doc = "Calls [Fold`::fold_declaration`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_declaration(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Declaration {
                 span,
@@ -102244,46 +82097,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Declaration {
                 value,
                 important,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Name,
-                    ));
-                    <DeclarationName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let important = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
-                        self::fields::DeclarationField::Important,
-                    ));
-                    <Option<ImportantFlag> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        important,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <DeclarationName as FoldWith<V>>::fold_with(name, visitor) };
+                let value = { <Vec<ComponentValue> as FoldWith<V>>::fold_with(value, visitor) };
+                let important =
+                    { <Option<ImportantFlag> as FoldWith<V>>::fold_with(important, visitor) };
                 Declaration {
                     span,
                     name,
@@ -102294,132 +82112,72 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Declaration {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DeclarationName {
-    #[doc = "Calls [FoldAstPath`::fold_declaration_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_declaration_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DeclarationName {
+    #[doc = "Calls [Fold`::fold_declaration_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_declaration_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DeclarationName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
-                    self::fields::DeclarationNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 DeclarationName::Ident { 0: _field_0 }
             }
             DeclarationName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
-                    self::fields::DeclarationNameField::DashedIdent,
-                ));
-                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 DeclarationName::DashedIdent { 0: _field_0 }
             }
         }
     }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DeclarationOrAtRule {
-    #[doc = "Calls [FoldAstPath`::fold_declaration_or_at_rule`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_declaration_or_at_rule(visitor, self, __ast_path)
+}
+impl<V: ?Sized + Fold> FoldWith<V> for DeclarationOrAtRule {
+    #[doc = "Calls [Fold`::fold_declaration_or_at_rule`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_declaration_or_at_rule(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DeclarationOrAtRule::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
-                    self::fields::DeclarationOrAtRuleField::Declaration,
-                ));
-                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
                 DeclarationOrAtRule::Declaration { 0: _field_0 }
             }
             DeclarationOrAtRule::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
-                    self::fields::DeclarationOrAtRuleField::AtRule,
-                ));
-                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
                 DeclarationOrAtRule::AtRule { 0: _field_0 }
             }
             DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
-                    self::fields::DeclarationOrAtRuleField::ListOfComponentValues,
-                ));
                 let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
                 DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Delimiter {
-    #[doc = "Calls [FoldAstPath`::fold_delimiter`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_delimiter(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Delimiter {
+    #[doc = "Calls [Fold`::fold_delimiter`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_delimiter(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Delimiter { span, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Delimiter(self::fields::DelimiterField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Delimiter(
-                        self::fields::DelimiterField::Value,
-                    ));
-                    <DelimiterValue as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <DelimiterValue as FoldWith<V>>::fold_with(value, visitor) };
                 Delimiter { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DelimiterValue {
-    #[doc = "Calls [FoldAstPath`::fold_delimiter_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_delimiter_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DelimiterValue {
+    #[doc = "Calls [Fold`::fold_delimiter_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_delimiter_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DelimiterValue::Comma => DelimiterValue::Comma,
             DelimiterValue::Solidus => DelimiterValue::Solidus,
@@ -102427,103 +82185,52 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DelimiterValue {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Dimension {
-    #[doc = "Calls [FoldAstPath`::fold_dimension`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_dimension(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Dimension {
+    #[doc = "Calls [Fold`::fold_dimension`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_dimension(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Dimension::Length { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Length,
-                ));
-                let _field_0 = <Length as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Length as FoldWith<V>>::fold_with(_field_0, visitor);
                 Dimension::Length { 0: _field_0 }
             }
             Dimension::Angle { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Angle,
-                ));
-                let _field_0 = <Angle as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Angle as FoldWith<V>>::fold_with(_field_0, visitor);
                 Dimension::Angle { 0: _field_0 }
             }
             Dimension::Time { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Time));
-                let _field_0 = <Time as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Time as FoldWith<V>>::fold_with(_field_0, visitor);
                 Dimension::Time { 0: _field_0 }
             }
             Dimension::Frequency { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Frequency,
-                ));
-                let _field_0 = <Frequency as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Frequency as FoldWith<V>>::fold_with(_field_0, visitor);
                 Dimension::Frequency { 0: _field_0 }
             }
             Dimension::Resolution { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::Resolution,
-                ));
-                let _field_0 = <Resolution as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Resolution as FoldWith<V>>::fold_with(_field_0, visitor);
                 Dimension::Resolution { 0: _field_0 }
             }
             Dimension::Flex { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Flex));
-                let _field_0 = <Flex as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Flex as FoldWith<V>>::fold_with(_field_0, visitor);
                 Dimension::Flex { 0: _field_0 }
             }
             Dimension::UnknownDimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
-                    self::fields::DimensionField::UnknownDimension,
-                ));
-                let _field_0 = <UnknownDimension as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <UnknownDimension as FoldWith<V>>::fold_with(_field_0, visitor);
                 Dimension::UnknownDimension { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DimensionToken {
-    #[doc = "Calls [FoldAstPath`::fold_dimension_token`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_dimension_token(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DimensionToken {
+    #[doc = "Calls [Fold`::fold_dimension_token`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_dimension_token(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DimensionToken {
                 value,
@@ -102532,46 +82239,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DimensionToken {
                 type_flag,
                 raw_unit,
             } => {
-                let raw_value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::RawValue,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw_value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::Unit,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_flag = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::TypeFlag,
-                    ));
-                    <NumberType as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_flag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw_unit = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
-                        self::fields::DimensionTokenField::RawUnit,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw_unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let raw_value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw_value, visitor) };
+                let unit = { <swc_atoms::Atom as FoldWith<V>>::fold_with(unit, visitor) };
+                let type_flag = { <NumberType as FoldWith<V>>::fold_with(type_flag, visitor) };
+                let raw_unit = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw_unit, visitor) };
                 DimensionToken {
                     value,
                     raw_value,
@@ -102583,38 +82254,23 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DimensionToken {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DocumentPrelude {
-    #[doc = "Calls [FoldAstPath`::fold_document_prelude`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_document_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DocumentPrelude {
+    #[doc = "Calls [Fold`::fold_document_prelude`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_document_prelude(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DocumentPrelude {
                 span,
                 matching_functions,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
-                        self::fields::DocumentPreludeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 let matching_functions = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
-                        self::fields::DocumentPreludeField::MatchingFunctions(usize::MAX),
-                    ));
-                    <Vec<DocumentPreludeMatchingFunction> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    <Vec<DocumentPreludeMatchingFunction> as FoldWith<V>>::fold_with(
                         matching_functions,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 DocumentPrelude {
@@ -102625,748 +82281,348 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DocumentPrelude {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DocumentPreludeMatchingFunction {
-    #[doc = "Calls [FoldAstPath`::fold_document_prelude_matching_function`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_document_prelude_matching_function(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DocumentPreludeMatchingFunction {
+    #[doc = "Calls [Fold`::fold_document_prelude_matching_function`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_document_prelude_matching_function(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DocumentPreludeMatchingFunction::Url { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
-                        self::fields::DocumentPreludeMatchingFunctionField::Url,
-                    ));
-                let _field_0 = <Url as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Url as FoldWith<V>>::fold_with(_field_0, visitor);
                 DocumentPreludeMatchingFunction::Url { 0: _field_0 }
             }
             DocumentPreludeMatchingFunction::Function { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
-                        self::fields::DocumentPreludeMatchingFunctionField::Function,
-                    ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 DocumentPreludeMatchingFunction::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExtensionName {
-    #[doc = "Calls [FoldAstPath`::fold_extension_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_extension_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExtensionName {
+    #[doc = "Calls [Fold`::fold_extension_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_extension_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExtensionName { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
-                        self::fields::ExtensionNameField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
-                        self::fields::ExtensionNameField::Value,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
-                        self::fields::ExtensionNameField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 ExtensionName { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FamilyName {
-    #[doc = "Calls [FoldAstPath`::fold_family_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_family_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for FamilyName {
+    #[doc = "Calls [Fold`::fold_family_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_family_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             FamilyName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
-                    self::fields::FamilyNameField::Str,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 FamilyName::Str { 0: _field_0 }
             }
             FamilyName::SequenceOfCustomIdents { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
-                    self::fields::FamilyNameField::SequenceOfCustomIdents,
-                ));
-                let _field_0 = <SequenceOfCustomIdents as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <SequenceOfCustomIdents as FoldWith<V>>::fold_with(_field_0, visitor);
                 FamilyName::SequenceOfCustomIdents { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Flex {
-    #[doc = "Calls [FoldAstPath`::fold_flex`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_flex(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Flex {
+    #[doc = "Calls [Fold`::fold_flex`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_flex(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Flex { span, value, unit } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Value));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Unit));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
+                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
                 Flex { span, value, unit }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FontFeatureValuesPrelude {
-    #[doc = "Calls [FoldAstPath`::fold_font_feature_values_prelude`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_font_feature_values_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for FontFeatureValuesPrelude {
+    #[doc = "Calls [Fold`::fold_font_feature_values_prelude`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_font_feature_values_prelude(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             FontFeatureValuesPrelude { span, font_family } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
-                            self::fields::FontFeatureValuesPreludeField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let font_family = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
-                            self::fields::FontFeatureValuesPreludeField::FontFamily(usize::MAX),
-                        ));
-                    <Vec<FamilyName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        font_family,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let font_family =
+                    { <Vec<FamilyName> as FoldWith<V>>::fold_with(font_family, visitor) };
                 FontFeatureValuesPrelude { span, font_family }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingComplexSelector {
-    #[doc = "Calls [FoldAstPath`::fold_forgiving_complex_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_forgiving_complex_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForgivingComplexSelector {
+    #[doc = "Calls [Fold`::fold_forgiving_complex_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_forgiving_complex_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ForgivingComplexSelector::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
-                        self::fields::ForgivingComplexSelectorField::ComplexSelector,
-                    ));
-                let _field_0 = <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ComplexSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 ForgivingComplexSelector::ComplexSelector { 0: _field_0 }
             }
             ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
-                        self::fields::ForgivingComplexSelectorField::ListOfComponentValues,
-                    ));
-                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
                 ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingRelativeSelector {
-    #[doc = "Calls [FoldAstPath`::fold_forgiving_relative_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_forgiving_relative_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForgivingRelativeSelector {
+    #[doc = "Calls [Fold`::fold_forgiving_relative_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_forgiving_relative_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ForgivingRelativeSelector::RelativeSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
-                        self::fields::ForgivingRelativeSelectorField::RelativeSelector,
-                    ));
-                let _field_0 = <RelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <RelativeSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 ForgivingRelativeSelector::RelativeSelector { 0: _field_0 }
             }
             ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
-                        self::fields::ForgivingRelativeSelectorField::ListOfComponentValues,
-                    ));
-                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
                 ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingRelativeSelectorList {
-    #[doc = "Calls [FoldAstPath`::fold_forgiving_relative_selector_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_forgiving_relative_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForgivingRelativeSelectorList {
+    #[doc = "Calls [Fold`::fold_forgiving_relative_selector_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_forgiving_relative_selector_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            ForgivingRelativeSelectorList { span, children } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
-                            self::fields::ForgivingRelativeSelectorListField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            ForgivingRelativeSelectorList { span, children } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 let children = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
-                            self::fields::ForgivingRelativeSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<ForgivingRelativeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ForgivingRelativeSelector> as FoldWith<V>>::fold_with(children, visitor)
                 };
                 ForgivingRelativeSelectorList { span, children }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingSelectorList {
-    #[doc = "Calls [FoldAstPath`::fold_forgiving_selector_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_forgiving_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForgivingSelectorList {
+    #[doc = "Calls [Fold`::fold_forgiving_selector_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_forgiving_selector_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ForgivingSelectorList { span, children } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
-                            self::fields::ForgivingSelectorListField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 let children = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
-                            self::fields::ForgivingSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<ForgivingComplexSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ForgivingComplexSelector> as FoldWith<V>>::fold_with(children, visitor)
                 };
                 ForgivingSelectorList { span, children }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Frequency {
-    #[doc = "Calls [FoldAstPath`::fold_frequency`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_frequency(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Frequency {
+    #[doc = "Calls [Fold`::fold_frequency`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_frequency(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Frequency { span, value, unit } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Frequency(
-                        self::fields::FrequencyField::Value,
-                    ));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Unit));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
+                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
                 Frequency { span, value, unit }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FrequencyPercentage {
-    #[doc = "Calls [FoldAstPath`::fold_frequency_percentage`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_frequency_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for FrequencyPercentage {
+    #[doc = "Calls [Fold`::fold_frequency_percentage`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_frequency_percentage(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             FrequencyPercentage::Frequency { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
-                    self::fields::FrequencyPercentageField::Frequency,
-                ));
-                let _field_0 = <Frequency as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Frequency as FoldWith<V>>::fold_with(_field_0, visitor);
                 FrequencyPercentage::Frequency { 0: _field_0 }
             }
             FrequencyPercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
-                    self::fields::FrequencyPercentageField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
                 FrequencyPercentage::Percentage { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Function {
-    #[doc = "Calls [FoldAstPath`::fold_function`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_function(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Function {
+    #[doc = "Calls [Fold`::fold_function`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_function(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Function { span, name, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Name));
-                    <FunctionName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <FunctionName as FoldWith<V>>::fold_with(name, visitor) };
+                let value = { <Vec<ComponentValue> as FoldWith<V>>::fold_with(value, visitor) };
                 Function { span, name, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FunctionName {
-    #[doc = "Calls [FoldAstPath`::fold_function_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_function_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for FunctionName {
+    #[doc = "Calls [Fold`::fold_function_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_function_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             FunctionName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
-                    self::fields::FunctionNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 FunctionName::Ident { 0: _field_0 }
             }
             FunctionName::DashedIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
-                    self::fields::FunctionNameField::DashedIdent,
-                ));
-                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DashedIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 FunctionName::DashedIdent { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for GeneralEnclosed {
-    #[doc = "Calls [FoldAstPath`::fold_general_enclosed`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_general_enclosed(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for GeneralEnclosed {
+    #[doc = "Calls [Fold`::fold_general_enclosed`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_general_enclosed(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             GeneralEnclosed::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
-                    self::fields::GeneralEnclosedField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 GeneralEnclosed::Function { 0: _field_0 }
             }
             GeneralEnclosed::SimpleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
-                    self::fields::GeneralEnclosedField::SimpleBlock,
-                ));
-                let _field_0 = <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SimpleBlock as FoldWith<V>>::fold_with(_field_0, visitor);
                 GeneralEnclosed::SimpleBlock { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for HexColor {
-    #[doc = "Calls [FoldAstPath`::fold_hex_color`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_hex_color(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for HexColor {
+    #[doc = "Calls [Fold`::fold_hex_color`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_hex_color(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             HexColor { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 HexColor { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Hue {
-    #[doc = "Calls [FoldAstPath`::fold_hue`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_hue(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Hue {
+    #[doc = "Calls [Fold`::fold_hue`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_hue(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Hue::Number { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Number));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 Hue::Number { 0: _field_0 }
             }
             Hue::Angle { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Angle));
-                let _field_0 = <Angle as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Angle as FoldWith<V>>::fold_with(_field_0, visitor);
                 Hue::Angle { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for IdSelector {
-    #[doc = "Calls [FoldAstPath`::fold_id_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_id_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for IdSelector {
+    #[doc = "Calls [Fold`::fold_id_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_id_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             IdSelector { span, text } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
-                        self::fields::IdSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let text = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
-                        self::fields::IdSelectorField::Text,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        text,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let text = { <Ident as FoldWith<V>>::fold_with(text, visitor) };
                 IdSelector { span, text }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ident {
-    #[doc = "Calls [FoldAstPath`::fold_ident`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Ident {
+    #[doc = "Calls [Fold`::fold_ident`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ident(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Ident { span, value, raw } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Ident(self::fields::IdentField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 Ident { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportConditions {
-    #[doc = "Calls [FoldAstPath`::fold_import_conditions`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_conditions(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportConditions {
+    #[doc = "Calls [Fold`::fold_import_conditions`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_conditions(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportConditions {
                 span,
                 supports,
                 media,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
-                        self::fields::ImportConditionsField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let supports = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
-                        self::fields::ImportConditionsField::Supports,
-                    ));
-                    <Option<Box<Function>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        supports,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let media = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
-                        self::fields::ImportConditionsField::Media,
-                    ));
-                    <Option<Box<MediaQueryList>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        media,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let supports =
+                    { <Option<Box<Function>> as FoldWith<V>>::fold_with(supports, visitor) };
+                let media =
+                    { <Option<Box<MediaQueryList>> as FoldWith<V>>::fold_with(media, visitor) };
                 ImportConditions {
                     span,
                     supports,
@@ -103376,130 +82632,67 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportConditions {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportHref {
-    #[doc = "Calls [FoldAstPath`::fold_import_href`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_href(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportHref {
+    #[doc = "Calls [Fold`::fold_import_href`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_href(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportHref::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
-                    self::fields::ImportHrefField::Url,
-                ));
-                let _field_0 = <Url as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Url as FoldWith<V>>::fold_with(_field_0, visitor);
                 ImportHref::Url { 0: _field_0 }
             }
             ImportHref::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
-                    self::fields::ImportHrefField::Str,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 ImportHref::Str { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportLayerName {
-    #[doc = "Calls [FoldAstPath`::fold_import_layer_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_layer_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportLayerName {
+    #[doc = "Calls [Fold`::fold_import_layer_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_layer_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportLayerName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
-                    self::fields::ImportLayerNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 ImportLayerName::Ident { 0: _field_0 }
             }
             ImportLayerName::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
-                    self::fields::ImportLayerNameField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 ImportLayerName::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportPrelude {
-    #[doc = "Calls [FoldAstPath`::fold_import_prelude`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportPrelude {
+    #[doc = "Calls [Fold`::fold_import_prelude`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_prelude(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportPrelude {
                 span,
                 href,
-                layer_name,
-                import_conditions,
-            } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let href = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::Href,
-                    ));
-                    <Box<ImportHref> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        href,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                layer_name,
+                import_conditions,
+            } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let href = { <Box<ImportHref> as FoldWith<V>>::fold_with(href, visitor) };
                 let layer_name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::LayerName,
-                    ));
-                    <Option<Box<ImportLayerName>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        layer_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ImportLayerName>> as FoldWith<V>>::fold_with(layer_name, visitor)
                 };
                 let import_conditions = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
-                        self::fields::ImportPreludeField::ImportConditions,
-                    ));
-                    <Option<Box<ImportConditions>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    <Option<Box<ImportConditions>> as FoldWith<V>>::fold_with(
                         import_conditions,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 ImportPrelude {
@@ -103512,121 +82705,55 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportPrelude {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportantFlag {
-    #[doc = "Calls [FoldAstPath`::fold_important_flag`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_important_flag(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportantFlag {
+    #[doc = "Calls [Fold`::fold_important_flag`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_important_flag(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportantFlag { span, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
-                        self::fields::ImportantFlagField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
-                        self::fields::ImportantFlagField::Value,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
                 ImportantFlag { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Integer {
-    #[doc = "Calls [FoldAstPath`::fold_integer`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_integer(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Integer {
+    #[doc = "Calls [Fold`::fold_integer`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_integer(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Integer { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 Integer { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframeBlock {
-    #[doc = "Calls [FoldAstPath`::fold_keyframe_block`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_keyframe_block(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for KeyframeBlock {
+    #[doc = "Calls [Fold`::fold_keyframe_block`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_keyframe_block(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             KeyframeBlock {
                 span,
                 prelude,
                 block,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
-                        self::fields::KeyframeBlockField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prelude = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
-                        self::fields::KeyframeBlockField::Prelude(usize::MAX),
-                    ));
-                    <Vec<KeyframeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let block = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
-                        self::fields::KeyframeBlockField::Block,
-                    ));
-                    <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let prelude =
+                    { <Vec<KeyframeSelector> as FoldWith<V>>::fold_with(prelude, visitor) };
+                let block = { <SimpleBlock as FoldWith<V>>::fold_with(block, visitor) };
                 KeyframeBlock {
                     span,
                     prelude,
@@ -103636,464 +82763,208 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframeBlock {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframeSelector {
-    #[doc = "Calls [FoldAstPath`::fold_keyframe_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_keyframe_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for KeyframeSelector {
+    #[doc = "Calls [Fold`::fold_keyframe_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_keyframe_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             KeyframeSelector::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
-                    self::fields::KeyframeSelectorField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 KeyframeSelector::Ident { 0: _field_0 }
             }
             KeyframeSelector::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
-                    self::fields::KeyframeSelectorField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
                 KeyframeSelector::Percentage { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframesName {
-    #[doc = "Calls [FoldAstPath`::fold_keyframes_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_keyframes_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for KeyframesName {
+    #[doc = "Calls [Fold`::fold_keyframes_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_keyframes_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             KeyframesName::CustomIdent { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::CustomIdent,
-                ));
-                let _field_0 = <Box<CustomIdent> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<CustomIdent> as FoldWith<V>>::fold_with(_field_0, visitor);
                 KeyframesName::CustomIdent { 0: _field_0 }
             }
             KeyframesName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::Str,
-                ));
-                let _field_0 = <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Str> as FoldWith<V>>::fold_with(_field_0, visitor);
                 KeyframesName::Str { 0: _field_0 }
             }
             KeyframesName::PseudoPrefix { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::PseudoPrefix,
-                ));
                 let _field_0 =
-                    <Box<KeyframesPseudoPrefix> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <Box<KeyframesPseudoPrefix> as FoldWith<V>>::fold_with(_field_0, visitor);
                 KeyframesName::PseudoPrefix { 0: _field_0 }
             }
             KeyframesName::PseudoFunction { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
-                    self::fields::KeyframesNameField::PseudoFunction,
-                ));
                 let _field_0 =
-                    <Box<KeyframesPseudoFunction> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <Box<KeyframesPseudoFunction> as FoldWith<V>>::fold_with(_field_0, visitor);
                 KeyframesName::PseudoFunction { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframesPseudoFunction {
-    #[doc = "Calls [FoldAstPath`::fold_keyframes_pseudo_function`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_keyframes_pseudo_function(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for KeyframesPseudoFunction {
+    #[doc = "Calls [Fold`::fold_keyframes_pseudo_function`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_keyframes_pseudo_function(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             KeyframesPseudoFunction { span, pseudo, name } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
-                            self::fields::KeyframesPseudoFunctionField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let pseudo = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
-                            self::fields::KeyframesPseudoFunctionField::Pseudo,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        pseudo,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
-                            self::fields::KeyframesPseudoFunctionField::Name,
-                        ));
-                    <KeyframesName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let pseudo = { <Ident as FoldWith<V>>::fold_with(pseudo, visitor) };
+                let name = { <KeyframesName as FoldWith<V>>::fold_with(name, visitor) };
                 KeyframesPseudoFunction { span, pseudo, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframesPseudoPrefix {
-    #[doc = "Calls [FoldAstPath`::fold_keyframes_pseudo_prefix`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_keyframes_pseudo_prefix(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for KeyframesPseudoPrefix {
+    #[doc = "Calls [Fold`::fold_keyframes_pseudo_prefix`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_keyframes_pseudo_prefix(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             KeyframesPseudoPrefix { span, pseudo, name } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
-                            self::fields::KeyframesPseudoPrefixField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let pseudo = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
-                            self::fields::KeyframesPseudoPrefixField::Pseudo,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        pseudo,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
-                            self::fields::KeyframesPseudoPrefixField::Name,
-                        ));
-                    <KeyframesName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let pseudo = { <Ident as FoldWith<V>>::fold_with(pseudo, visitor) };
+                let name = { <KeyframesName as FoldWith<V>>::fold_with(name, visitor) };
                 KeyframesPseudoPrefix { span, pseudo, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LayerName {
-    #[doc = "Calls [FoldAstPath`::fold_layer_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_layer_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for LayerName {
+    #[doc = "Calls [Fold`::fold_layer_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_layer_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             LayerName { span, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::LayerName(self::fields::LayerNameField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerName(
-                        self::fields::LayerNameField::Name(usize::MAX),
-                    ));
-                    <Vec<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Vec<Ident> as FoldWith<V>>::fold_with(name, visitor) };
                 LayerName { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LayerNameList {
-    #[doc = "Calls [FoldAstPath`::fold_layer_name_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_layer_name_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for LayerNameList {
+    #[doc = "Calls [Fold`::fold_layer_name_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_layer_name_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             LayerNameList { span, name_list } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
-                        self::fields::LayerNameListField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name_list = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
-                        self::fields::LayerNameListField::NameList(usize::MAX),
-                    ));
-                    <Vec<LayerName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name_list,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name_list = { <Vec<LayerName> as FoldWith<V>>::fold_with(name_list, visitor) };
                 LayerNameList { span, name_list }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LayerPrelude {
-    #[doc = "Calls [FoldAstPath`::fold_layer_prelude`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_layer_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for LayerPrelude {
+    #[doc = "Calls [Fold`::fold_layer_prelude`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_layer_prelude(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             LayerPrelude::Name { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
-                    self::fields::LayerPreludeField::Name,
-                ));
-                let _field_0 = <LayerName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <LayerName as FoldWith<V>>::fold_with(_field_0, visitor);
                 LayerPrelude::Name { 0: _field_0 }
             }
             LayerPrelude::NameList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
-                    self::fields::LayerPreludeField::NameList,
-                ));
-                let _field_0 = <LayerNameList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <LayerNameList as FoldWith<V>>::fold_with(_field_0, visitor);
                 LayerPrelude::NameList { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Length {
-    #[doc = "Calls [FoldAstPath`::fold_length`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_length(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Length {
+    #[doc = "Calls [Fold`::fold_length`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_length(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Length { span, value, unit } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Length(self::fields::LengthField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Length(self::fields::LengthField::Value));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Length(self::fields::LengthField::Unit));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
+                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
                 Length { span, value, unit }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LengthPercentage {
-    #[doc = "Calls [FoldAstPath`::fold_length_percentage`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_length_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for LengthPercentage {
+    #[doc = "Calls [Fold`::fold_length_percentage`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_length_percentage(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             LengthPercentage::Length { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
-                    self::fields::LengthPercentageField::Length,
-                ));
-                let _field_0 = <Length as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Length as FoldWith<V>>::fold_with(_field_0, visitor);
                 LengthPercentage::Length { 0: _field_0 }
             }
             LengthPercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
-                    self::fields::LengthPercentageField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                LengthPercentage::Percentage { 0: _field_0 }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ListOfComponentValues {
-    #[doc = "Calls [FoldAstPath`::fold_list_of_component_values`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_list_of_component_values(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            ListOfComponentValues { span, children } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
-                            self::fields::ListOfComponentValuesField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let children = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
-                            self::fields::ListOfComponentValuesField::Children(usize::MAX),
-                        ));
-                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
+                LengthPercentage::Percentage { 0: _field_0 }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for ListOfComponentValues {
+    #[doc = "Calls [Fold`::fold_list_of_component_values`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_list_of_component_values(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            ListOfComponentValues { span, children } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let children =
+                    { <Vec<ComponentValue> as FoldWith<V>>::fold_with(children, visitor) };
                 ListOfComponentValues { span, children }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaAnd {
-    #[doc = "Calls [FoldAstPath`::fold_media_and`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_and(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaAnd {
+    #[doc = "Calls [Fold`::fold_media_and`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_and(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaAnd {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaAnd(self::fields::MediaAndField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
-                        self::fields::MediaAndField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let condition = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
-                        self::fields::MediaAndField::Condition,
-                    ));
-                    <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let condition = { <MediaInParens as FoldWith<V>>::fold_with(condition, visitor) };
                 MediaAnd {
                     span,
                     keyword,
@@ -104103,165 +82974,83 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaAnd {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaCondition {
-    #[doc = "Calls [FoldAstPath`::fold_media_condition`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_condition(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaCondition {
+    #[doc = "Calls [Fold`::fold_media_condition`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_condition(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaCondition { span, conditions } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
-                        self::fields::MediaConditionField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let conditions = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
-                        self::fields::MediaConditionField::Conditions(usize::MAX),
-                    ));
-                    <Vec<MediaConditionAllType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let conditions =
+                    { <Vec<MediaConditionAllType> as FoldWith<V>>::fold_with(conditions, visitor) };
                 MediaCondition { span, conditions }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionAllType {
-    #[doc = "Calls [FoldAstPath`::fold_media_condition_all_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_condition_all_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionAllType {
+    #[doc = "Calls [Fold`::fold_media_condition_all_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_condition_all_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaConditionAllType::Not { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::Not,
-                ));
-                let _field_0 = <MediaNot as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaNot as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionAllType::Not { 0: _field_0 }
             }
             MediaConditionAllType::And { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::And,
-                ));
-                let _field_0 = <MediaAnd as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaAnd as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionAllType::And { 0: _field_0 }
             }
             MediaConditionAllType::Or { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::Or,
-                ));
-                let _field_0 = <MediaOr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaOr as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionAllType::Or { 0: _field_0 }
             }
             MediaConditionAllType::MediaInParens { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
-                    self::fields::MediaConditionAllTypeField::MediaInParens,
-                ));
-                let _field_0 = <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaInParens as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionAllType::MediaInParens { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionType {
-    #[doc = "Calls [FoldAstPath`::fold_media_condition_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_condition_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionType {
+    #[doc = "Calls [Fold`::fold_media_condition_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_condition_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaConditionType::All { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
-                    self::fields::MediaConditionTypeField::All,
-                ));
-                let _field_0 = <MediaCondition as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaCondition as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionType::All { 0: _field_0 }
             }
             MediaConditionType::WithoutOr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
-                    self::fields::MediaConditionTypeField::WithoutOr,
-                ));
-                let _field_0 = <MediaConditionWithoutOr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <MediaConditionWithoutOr as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionType::WithoutOr { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionWithoutOr {
-    #[doc = "Calls [FoldAstPath`::fold_media_condition_without_or`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_condition_without_or(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionWithoutOr {
+    #[doc = "Calls [Fold`::fold_media_condition_without_or`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_condition_without_or(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaConditionWithoutOr { span, conditions } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
-                            self::fields::MediaConditionWithoutOrField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 let conditions = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
-                            self::fields::MediaConditionWithoutOrField::Conditions(usize::MAX),
-                        ));
-                    <Vec<MediaConditionWithoutOrType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
+                    <Vec<MediaConditionWithoutOrType> as FoldWith<V>>::fold_with(
+                        conditions, visitor,
                     )
                 };
                 MediaConditionWithoutOr { span, conditions }
@@ -104269,239 +83058,116 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionWithoutOr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionWithoutOrType {
-    #[doc = "Calls [FoldAstPath`::fold_media_condition_without_or_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_condition_without_or_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaConditionWithoutOrType {
+    #[doc = "Calls [Fold`::fold_media_condition_without_or_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_condition_without_or_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaConditionWithoutOrType::Not { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
-                        self::fields::MediaConditionWithoutOrTypeField::Not,
-                    ));
-                let _field_0 = <MediaNot as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaNot as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionWithoutOrType::Not { 0: _field_0 }
             }
             MediaConditionWithoutOrType::And { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
-                        self::fields::MediaConditionWithoutOrTypeField::And,
-                    ));
-                let _field_0 = <MediaAnd as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaAnd as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionWithoutOrType::And { 0: _field_0 }
             }
             MediaConditionWithoutOrType::MediaInParens { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
-                        self::fields::MediaConditionWithoutOrTypeField::MediaInParens,
-                    ));
-                let _field_0 = <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaInParens as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaConditionWithoutOrType::MediaInParens { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeature {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeature {
+    #[doc = "Calls [Fold`::fold_media_feature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeature::Plain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::Plain,
-                ));
-                let _field_0 = <MediaFeaturePlain as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaFeaturePlain as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeature::Plain { 0: _field_0 }
             }
             MediaFeature::Boolean { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::Boolean,
-                ));
-                let _field_0 = <MediaFeatureBoolean as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaFeatureBoolean as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeature::Boolean { 0: _field_0 }
             }
             MediaFeature::Range { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::Range,
-                ));
-                let _field_0 = <MediaFeatureRange as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaFeatureRange as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeature::Range { 0: _field_0 }
             }
             MediaFeature::RangeInterval { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
-                    self::fields::MediaFeatureField::RangeInterval,
-                ));
                 let _field_0 =
-                    <MediaFeatureRangeInterval as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <MediaFeatureRangeInterval as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeature::RangeInterval { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureBoolean {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature_boolean`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature_boolean(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureBoolean {
+    #[doc = "Calls [Fold`::fold_media_feature_boolean`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature_boolean(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeatureBoolean { span, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
-                        self::fields::MediaFeatureBooleanField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
-                        self::fields::MediaFeatureBooleanField::Name,
-                    ));
-                    <MediaFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <MediaFeatureName as FoldWith<V>>::fold_with(name, visitor) };
                 MediaFeatureBoolean { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureName {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureName {
+    #[doc = "Calls [Fold`::fold_media_feature_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeatureName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
-                    self::fields::MediaFeatureNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeatureName::Ident { 0: _field_0 }
             }
             MediaFeatureName::ExtensionName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
-                    self::fields::MediaFeatureNameField::ExtensionName,
-                ));
-                let _field_0 = <ExtensionName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ExtensionName as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeatureName::ExtensionName { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeaturePlain {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature_plain`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature_plain(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeaturePlain {
+    #[doc = "Calls [Fold`::fold_media_feature_plain`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature_plain(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeaturePlain { span, name, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
-                        self::fields::MediaFeaturePlainField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
-                        self::fields::MediaFeaturePlainField::Name,
-                    ));
-                    <MediaFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
-                        self::fields::MediaFeaturePlainField::Value,
-                    ));
-                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <MediaFeatureName as FoldWith<V>>::fold_with(name, visitor) };
+                let value = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(value, visitor) };
                 MediaFeaturePlain { span, name, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRange {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature_range`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature_range(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRange {
+    #[doc = "Calls [Fold`::fold_media_feature_range`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature_range(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeatureRange {
                 span,
@@ -104509,46 +83175,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRange {
                 comparison,
                 right,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Left,
-                    ));
-                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
                 let comparison = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Comparison,
-                    ));
-                    <MediaFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
-                        comparison,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
-                        self::fields::MediaFeatureRangeField::Right,
-                    ));
-                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MediaFeatureRangeComparison as FoldWith<V>>::fold_with(comparison, visitor)
                 };
+                let right = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
                 MediaFeatureRange {
                     span,
                     left,
@@ -104559,15 +83191,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRange {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRangeComparison {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature_range_comparison`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature_range_comparison(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRangeComparison {
+    #[doc = "Calls [Fold`::fold_media_feature_range_comparison`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature_range_comparison(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeatureRangeComparison::Lt => MediaFeatureRangeComparison::Lt,
             MediaFeatureRangeComparison::Le => MediaFeatureRangeComparison::Le,
@@ -104577,90 +83207,38 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRangeComparison
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRangeInterval {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature_range_interval`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature_range_interval(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureRangeInterval {
+    #[doc = "Calls [Fold`::fold_media_feature_range_interval`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature_range_interval(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeatureRangeInterval {
                 span,
                 left,
                 left_comparison,
                 name,
-                right_comparison,
-                right,
-            } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Left,
-                        ));
-                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                right_comparison,
+                right,
+            } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
                 let left_comparison = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::LeftComparison,
-                        ));
-                    <MediaFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
+                    <MediaFeatureRangeComparison as FoldWith<V>>::fold_with(
                         left_comparison,
                         visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Name,
-                        ));
-                    <MediaFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
                     )
                 };
+                let name = { <MediaFeatureName as FoldWith<V>>::fold_with(name, visitor) };
                 let right_comparison = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::RightComparison,
-                        ));
-                    <MediaFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
+                    <MediaFeatureRangeComparison as FoldWith<V>>::fold_with(
                         right_comparison,
                         visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
-                            self::fields::MediaFeatureRangeIntervalField::Right,
-                        ));
-                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
                     )
                 };
+                let right = { <Box<MediaFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
                 MediaFeatureRangeInterval {
                     span,
                     left,
@@ -104673,164 +83251,76 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRangeInterval {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureValue {
-    #[doc = "Calls [FoldAstPath`::fold_media_feature_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_feature_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaFeatureValue {
+    #[doc = "Calls [Fold`::fold_media_feature_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_feature_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaFeatureValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Number,
-                ));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeatureValue::Number { 0: _field_0 }
             }
             MediaFeatureValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Dimension,
-                ));
-                let _field_0 = <Dimension as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Dimension as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeatureValue::Dimension { 0: _field_0 }
             }
             MediaFeatureValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeatureValue::Ident { 0: _field_0 }
             }
             MediaFeatureValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Ratio,
-                ));
-                let _field_0 = <Ratio as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ratio as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeatureValue::Ratio { 0: _field_0 }
             }
             MediaFeatureValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
-                    self::fields::MediaFeatureValueField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaFeatureValue::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaInParens {
-    #[doc = "Calls [FoldAstPath`::fold_media_in_parens`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaInParens {
+    #[doc = "Calls [Fold`::fold_media_in_parens`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_in_parens(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaInParens::MediaCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
-                    self::fields::MediaInParensField::MediaCondition,
-                ));
-                let _field_0 = <MediaCondition as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MediaCondition as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaInParens::MediaCondition { 0: _field_0 }
             }
             MediaInParens::Feature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
-                    self::fields::MediaInParensField::Feature,
-                ));
-                let _field_0 = <Box<MediaFeature> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<MediaFeature> as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaInParens::Feature { 0: _field_0 }
             }
             MediaInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
-                    self::fields::MediaInParensField::GeneralEnclosed,
-                ));
-                let _field_0 = <GeneralEnclosed as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <GeneralEnclosed as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaInParens::GeneralEnclosed { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaNot {
-    #[doc = "Calls [FoldAstPath`::fold_media_not`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_not(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaNot {
+    #[doc = "Calls [Fold`::fold_media_not`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_not(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaNot {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaNot(self::fields::MediaNotField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
-                        self::fields::MediaNotField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let condition = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
-                        self::fields::MediaNotField::Condition,
-                    ));
-                    <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let condition = { <MediaInParens as FoldWith<V>>::fold_with(condition, visitor) };
                 MediaNot {
                     span,
                     keyword,
@@ -104840,49 +83330,22 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaNot {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaOr {
-    #[doc = "Calls [FoldAstPath`::fold_media_or`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_or(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaOr {
+    #[doc = "Calls [Fold`::fold_media_or`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_or(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaOr {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Keyword));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let condition = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaOr(
-                        self::fields::MediaOrField::Condition,
-                    ));
-                    <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let condition = { <MediaInParens as FoldWith<V>>::fold_with(condition, visitor) };
                 MediaOr {
                     span,
                     keyword,
@@ -104892,15 +83355,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaOr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaQuery {
-    #[doc = "Calls [FoldAstPath`::fold_media_query`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_query(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaQuery {
+    #[doc = "Calls [Fold`::fold_media_query`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_query(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaQuery {
                 span,
@@ -104909,55 +83370,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaQuery {
                 keyword,
                 condition,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let modifier = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Modifier,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        modifier,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let media_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::MediaType,
-                    ));
-                    <Option<MediaType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        media_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let modifier = { <Option<Ident> as FoldWith<V>>::fold_with(modifier, visitor) };
+                let media_type =
+                    { <Option<MediaType> as FoldWith<V>>::fold_with(media_type, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
                 let condition = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
-                        self::fields::MediaQueryField::Condition,
-                    ));
-                    <Option<Box<MediaConditionType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<MediaConditionType>> as FoldWith<V>>::fold_with(condition, visitor)
                 };
                 MediaQuery {
                     span,
@@ -104970,372 +83389,187 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaQuery {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaQueryList {
-    #[doc = "Calls [FoldAstPath`::fold_media_query_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_query_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaQueryList {
+    #[doc = "Calls [Fold`::fold_media_query_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_query_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaQueryList { span, queries } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
-                        self::fields::MediaQueryListField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let queries = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
-                        self::fields::MediaQueryListField::Queries(usize::MAX),
-                    ));
-                    <Vec<MediaQuery> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        queries,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let queries = { <Vec<MediaQuery> as FoldWith<V>>::fold_with(queries, visitor) };
                 MediaQueryList { span, queries }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaType {
-    #[doc = "Calls [FoldAstPath`::fold_media_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MediaType {
+    #[doc = "Calls [Fold`::fold_media_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MediaType::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaType(
-                    self::fields::MediaTypeField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 MediaType::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamedNamespace {
-    #[doc = "Calls [FoldAstPath`::fold_named_namespace`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_named_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NamedNamespace {
+    #[doc = "Calls [Fold`::fold_named_namespace`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_named_namespace(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             NamedNamespace { span, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
-                        self::fields::NamedNamespaceField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
-                        self::fields::NamedNamespaceField::Name,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
                 NamedNamespace { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Namespace {
-    #[doc = "Calls [FoldAstPath`::fold_namespace`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_namespace(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Namespace {
+    #[doc = "Calls [Fold`::fold_namespace`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_namespace(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Namespace::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Namespace(
-                    self::fields::NamespaceField::Named,
-                ));
-                let _field_0 = <NamedNamespace as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <NamedNamespace as FoldWith<V>>::fold_with(_field_0, visitor);
                 Namespace::Named { 0: _field_0 }
             }
             Namespace::Any { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Namespace(self::fields::NamespaceField::Any));
-                let _field_0 = <AnyNamespace as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AnyNamespace as FoldWith<V>>::fold_with(_field_0, visitor);
                 Namespace::Any { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamespacePrefix {
-    #[doc = "Calls [FoldAstPath`::fold_namespace_prefix`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_namespace_prefix(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NamespacePrefix {
+    #[doc = "Calls [Fold`::fold_namespace_prefix`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_namespace_prefix(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             NamespacePrefix { span, namespace } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
-                        self::fields::NamespacePrefixField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let namespace = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
-                        self::fields::NamespacePrefixField::Namespace,
-                    ));
-                    <Option<Namespace> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        namespace,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let namespace =
+                    { <Option<Namespace> as FoldWith<V>>::fold_with(namespace, visitor) };
                 NamespacePrefix { span, namespace }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamespacePrelude {
-    #[doc = "Calls [FoldAstPath`::fold_namespace_prelude`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_namespace_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NamespacePrelude {
+    #[doc = "Calls [Fold`::fold_namespace_prelude`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_namespace_prelude(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             NamespacePrelude { span, prefix, uri } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
-                        self::fields::NamespacePreludeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prefix = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
-                        self::fields::NamespacePreludeField::Prefix,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let uri = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
-                        self::fields::NamespacePreludeField::Uri,
-                    ));
-                    <Box<NamespacePreludeUri> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        uri,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let prefix = { <Option<Ident> as FoldWith<V>>::fold_with(prefix, visitor) };
+                let uri = { <Box<NamespacePreludeUri> as FoldWith<V>>::fold_with(uri, visitor) };
                 NamespacePrelude { span, prefix, uri }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamespacePreludeUri {
-    #[doc = "Calls [FoldAstPath`::fold_namespace_prelude_uri`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_namespace_prelude_uri(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NamespacePreludeUri {
+    #[doc = "Calls [Fold`::fold_namespace_prelude_uri`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_namespace_prelude_uri(visitor, self)
     }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            NamespacePreludeUri::Url { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
-                    self::fields::NamespacePreludeUriField::Url,
-                ));
-                let _field_0 = <Url as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            NamespacePreludeUri::Url { 0: _field_0 } => {
+                let _field_0 = <Url as FoldWith<V>>::fold_with(_field_0, visitor);
                 NamespacePreludeUri::Url { 0: _field_0 }
             }
             NamespacePreludeUri::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
-                    self::fields::NamespacePreludeUriField::Str,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 NamespacePreludeUri::Str { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NestingSelector {
-    #[doc = "Calls [FoldAstPath`::fold_nesting_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_nesting_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NestingSelector {
+    #[doc = "Calls [Fold`::fold_nesting_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_nesting_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             NestingSelector { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NestingSelector(
-                        self::fields::NestingSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 NestingSelector { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Number {
-    #[doc = "Calls [FoldAstPath`::fold_number`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_number(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Number {
+    #[doc = "Calls [Fold`::fold_number`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_number(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Number { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 Number { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NumberType {
-    #[doc = "Calls [FoldAstPath`::fold_number_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_number_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NumberType {
+    #[doc = "Calls [Fold`::fold_number_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_number_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             NumberType::Integer => NumberType::Integer,
             NumberType::Number => NumberType::Number,
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelector {
-    #[doc = "Calls [FoldAstPath`::fold_page_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_page_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PageSelector {
+    #[doc = "Calls [Fold`::fold_page_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_page_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PageSelector {
                 span,
                 page_type,
                 pseudos,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
-                        self::fields::PageSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let page_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
-                        self::fields::PageSelectorField::PageType,
-                    ));
-                    <Option<PageSelectorType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        page_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let page_type =
+                    { <Option<PageSelectorType> as FoldWith<V>>::fold_with(page_type, visitor) };
                 let pseudos = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
-                        self::fields::PageSelectorField::Pseudos(usize::MAX),
-                    ));
-                    <Option<Vec<PageSelectorPseudo>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        pseudos,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Vec<PageSelectorPseudo>> as FoldWith<V>>::fold_with(pseudos, visitor)
                 };
                 PageSelector {
                     span,
@@ -105346,190 +83580,90 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelector {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelectorList {
-    #[doc = "Calls [FoldAstPath`::fold_page_selector_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_page_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PageSelectorList {
+    #[doc = "Calls [Fold`::fold_page_selector_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_page_selector_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PageSelectorList { span, selectors } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
-                        self::fields::PageSelectorListField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let selectors = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
-                        self::fields::PageSelectorListField::Selectors(usize::MAX),
-                    ));
-                    <Vec<PageSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        selectors,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let selectors =
+                    { <Vec<PageSelector> as FoldWith<V>>::fold_with(selectors, visitor) };
                 PageSelectorList { span, selectors }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelectorPseudo {
-    #[doc = "Calls [FoldAstPath`::fold_page_selector_pseudo`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_page_selector_pseudo(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PageSelectorPseudo {
+    #[doc = "Calls [Fold`::fold_page_selector_pseudo`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_page_selector_pseudo(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PageSelectorPseudo { span, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
-                        self::fields::PageSelectorPseudoField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
-                        self::fields::PageSelectorPseudoField::Value,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
                 PageSelectorPseudo { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelectorType {
-    #[doc = "Calls [FoldAstPath`::fold_page_selector_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_page_selector_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PageSelectorType {
+    #[doc = "Calls [Fold`::fold_page_selector_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_page_selector_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PageSelectorType { span, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
-                        self::fields::PageSelectorTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
-                        self::fields::PageSelectorTypeField::Value,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
                 PageSelectorType { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Percentage {
-    #[doc = "Calls [FoldAstPath`::fold_percentage`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Percentage {
+    #[doc = "Calls [Fold`::fold_percentage`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_percentage(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Percentage { span, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
-                        self::fields::PercentageField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
-                        self::fields::PercentageField::Value,
-                    ));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
                 Percentage { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoClassSelector {
-    #[doc = "Calls [FoldAstPath`::fold_pseudo_class_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pseudo_class_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PseudoClassSelector {
+    #[doc = "Calls [Fold`::fold_pseudo_class_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pseudo_class_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PseudoClassSelector {
                 span,
                 name,
                 children,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
-                        self::fields::PseudoClassSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
-                        self::fields::PseudoClassSelectorField::Name,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
                 let children = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
-                        self::fields::PseudoClassSelectorField::Children(usize::MAX),
-                    ));
-                    < Option < Vec < PseudoClassSelectorChildren > > as FoldWithAstPath < V > > :: fold_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Option<Vec<PseudoClassSelectorChildren>> as FoldWith<V>>::fold_with(
+                        children, visitor,
+                    )
                 };
                 PseudoClassSelector {
                     span,
@@ -105540,207 +83674,85 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoClassSelector {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoClassSelectorChildren {
-    #[doc = "Calls [FoldAstPath`::fold_pseudo_class_selector_children`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pseudo_class_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PseudoClassSelectorChildren {
+    #[doc = "Calls [Fold`::fold_pseudo_class_selector_children`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pseudo_class_selector_children(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PseudoClassSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::PreservedToken,
-                    ));
-                let _field_0 = <TokenAndSpan as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TokenAndSpan as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::PreservedToken { 0: _field_0 }
             }
             PseudoClassSelectorChildren::AnPlusB { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::AnPlusB,
-                    ));
-                let _field_0 = <AnPlusB as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AnPlusB as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::AnPlusB { 0: _field_0 }
             }
             PseudoClassSelectorChildren::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::Ident,
-                    ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::Ident { 0: _field_0 }
             }
             PseudoClassSelectorChildren::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::Str,
-                    ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::Str { 0: _field_0 }
             }
             PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::Delimiter,
-                    ));
-                let _field_0 = <Delimiter as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Delimiter as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::Delimiter { 0: _field_0 }
             }
             PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::ComplexSelector,
-                    ));
-                let _field_0 = <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ComplexSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 }
             }
             PseudoClassSelectorChildren::SelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::SelectorList,
-                    ));
-                let _field_0 = <SelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::SelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::ForgivingSelectorList,
-                    ));
-                let _field_0 = <ForgivingSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ForgivingSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::CompoundSelectorList,
-                    ));
-                let _field_0 = <CompoundSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CompoundSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::RelativeSelectorList,
-                    ));
-                let _field_0 = <RelativeSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <RelativeSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PseudoClassSelectorChildren(
-                    self::fields::PseudoClassSelectorChildrenField::ForgivingRelativeSelectorList,
-                ));
                 let _field_0 =
-                    <ForgivingRelativeSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <ForgivingRelativeSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
-                        self::fields::PseudoClassSelectorChildrenField::CompoundSelector,
-                    ));
-                let _field_0 = <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CompoundSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoElementSelector {
-    #[doc = "Calls [FoldAstPath`::fold_pseudo_element_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pseudo_element_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PseudoElementSelector {
+    #[doc = "Calls [Fold`::fold_pseudo_element_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pseudo_element_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PseudoElementSelector {
                 span,
                 name,
                 children,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
-                            self::fields::PseudoElementSelectorField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
-                            self::fields::PseudoElementSelectorField::Name,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
                 let children = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
-                            self::fields::PseudoElementSelectorField::Children(usize::MAX),
-                        ));
-                    < Option < Vec < PseudoElementSelectorChildren > > as FoldWithAstPath < V > > :: fold_with_ast_path (children , visitor , & mut * __ast_path)
+                    <Option<Vec<PseudoElementSelectorChildren>> as FoldWith<V>>::fold_with(
+                        children, visitor,
+                    )
                 };
                 PseudoElementSelector {
                     span,
@@ -105751,112 +83763,50 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoElementSelector {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoElementSelectorChildren {
-    #[doc = "Calls [FoldAstPath`::fold_pseudo_element_selector_children`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pseudo_element_selector_children(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PseudoElementSelectorChildren {
+    #[doc = "Calls [Fold`::fold_pseudo_element_selector_children`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pseudo_element_selector_children(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PseudoElementSelectorChildren::PreservedToken { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::PreservedToken,
-                    ));
-                let _field_0 = <TokenAndSpan as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TokenAndSpan as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoElementSelectorChildren::PreservedToken { 0: _field_0 }
-            }
-            PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::Ident,
-                    ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+            }
+            PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoElementSelectorChildren::Ident { 0: _field_0 }
             }
             PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::CompoundSelector,
-                    ));
-                let _field_0 = <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CompoundSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 }
             }
             PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
-                        self::fields::PseudoElementSelectorChildrenField::CustomHighlightName,
-                    ));
-                let _field_0 = <CustomHighlightName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CustomHighlightName as FoldWith<V>>::fold_with(_field_0, visitor);
                 PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for QualifiedRule {
-    #[doc = "Calls [FoldAstPath`::fold_qualified_rule`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_qualified_rule(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for QualifiedRule {
+    #[doc = "Calls [Fold`::fold_qualified_rule`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_qualified_rule(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             QualifiedRule {
                 span,
                 prelude,
                 block,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
-                        self::fields::QualifiedRuleField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prelude = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
-                        self::fields::QualifiedRuleField::Prelude,
-                    ));
-                    <QualifiedRulePrelude as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prelude,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let block = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
-                        self::fields::QualifiedRuleField::Block,
-                    ));
-                    <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let prelude =
+                    { <QualifiedRulePrelude as FoldWith<V>>::fold_with(prelude, visitor) };
+                let block = { <SimpleBlock as FoldWith<V>>::fold_with(block, visitor) };
                 QualifiedRule {
                     span,
                     prelude,
@@ -105866,186 +83816,86 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for QualifiedRule {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for QualifiedRulePrelude {
-    #[doc = "Calls [FoldAstPath`::fold_qualified_rule_prelude`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_qualified_rule_prelude(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for QualifiedRulePrelude {
+    #[doc = "Calls [Fold`::fold_qualified_rule_prelude`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_qualified_rule_prelude(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             QualifiedRulePrelude::SelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
-                    self::fields::QualifiedRulePreludeField::SelectorList,
-                ));
-                let _field_0 = <SelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 QualifiedRulePrelude::SelectorList { 0: _field_0 }
             }
             QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
-                    self::fields::QualifiedRulePreludeField::RelativeSelectorList,
-                ));
-                let _field_0 = <RelativeSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <RelativeSelectorList as FoldWith<V>>::fold_with(_field_0, visitor);
                 QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 }
             }
             QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
-                    self::fields::QualifiedRulePreludeField::ListOfComponentValues,
-                ));
-                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ListOfComponentValues as FoldWith<V>>::fold_with(_field_0, visitor);
                 QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for QueryInParens {
-    #[doc = "Calls [FoldAstPath`::fold_query_in_parens`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_query_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for QueryInParens {
+    #[doc = "Calls [Fold`::fold_query_in_parens`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_query_in_parens(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             QueryInParens::ContainerQuery { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
-                    self::fields::QueryInParensField::ContainerQuery,
-                ));
-                let _field_0 = <Box<ContainerQuery> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<ContainerQuery> as FoldWith<V>>::fold_with(_field_0, visitor);
                 QueryInParens::ContainerQuery { 0: _field_0 }
             }
             QueryInParens::SizeFeature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
-                    self::fields::QueryInParensField::SizeFeature,
-                ));
-                let _field_0 = <SizeFeature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SizeFeature as FoldWith<V>>::fold_with(_field_0, visitor);
                 QueryInParens::SizeFeature { 0: _field_0 }
             }
             QueryInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
-                    self::fields::QueryInParensField::GeneralEnclosed,
-                ));
-                let _field_0 = <GeneralEnclosed as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <GeneralEnclosed as FoldWith<V>>::fold_with(_field_0, visitor);
                 QueryInParens::GeneralEnclosed { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ratio {
-    #[doc = "Calls [FoldAstPath`::fold_ratio`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ratio(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Ratio {
+    #[doc = "Calls [Fold`::fold_ratio`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ratio(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Ratio { span, left, right } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Left));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Ratio(self::fields::RatioField::Right));
-                    <Option<Number> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <Number as FoldWith<V>>::fold_with(left, visitor) };
+                let right = { <Option<Number> as FoldWith<V>>::fold_with(right, visitor) };
                 Ratio { span, left, right }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RelativeSelector {
-    #[doc = "Calls [FoldAstPath`::fold_relative_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_relative_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for RelativeSelector {
+    #[doc = "Calls [Fold`::fold_relative_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_relative_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             RelativeSelector {
                 span,
                 combinator,
                 selector,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
-                        self::fields::RelativeSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let combinator = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
-                        self::fields::RelativeSelectorField::Combinator,
-                    ));
-                    <Option<Combinator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        combinator,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let selector = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
-                        self::fields::RelativeSelectorField::Selector,
-                    ));
-                    <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                        selector,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let combinator =
+                    { <Option<Combinator> as FoldWith<V>>::fold_with(combinator, visitor) };
+                let selector = { <ComplexSelector as FoldWith<V>>::fold_with(selector, visitor) };
                 RelativeSelector {
                     span,
                     combinator,
@@ -106055,179 +83905,83 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RelativeSelector {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RelativeSelectorList {
-    #[doc = "Calls [FoldAstPath`::fold_relative_selector_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_relative_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for RelativeSelectorList {
+    #[doc = "Calls [Fold`::fold_relative_selector_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_relative_selector_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             RelativeSelectorList { span, children } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
-                            self::fields::RelativeSelectorListField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let children = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
-                            self::fields::RelativeSelectorListField::Children(usize::MAX),
-                        ));
-                    <Vec<RelativeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let children =
+                    { <Vec<RelativeSelector> as FoldWith<V>>::fold_with(children, visitor) };
                 RelativeSelectorList { span, children }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Resolution {
-    #[doc = "Calls [FoldAstPath`::fold_resolution`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_resolution(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Resolution {
+    #[doc = "Calls [Fold`::fold_resolution`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_resolution(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Resolution { span, value, unit } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
-                        self::fields::ResolutionField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
-                        self::fields::ResolutionField::Value,
-                    ));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
-                        self::fields::ResolutionField::Unit,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
+                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
                 Resolution { span, value, unit }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Rule {
-    #[doc = "Calls [FoldAstPath`::fold_rule`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_rule(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Rule {
+    #[doc = "Calls [Fold`::fold_rule`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_rule(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Rule::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Rule(self::fields::RuleField::QualifiedRule));
-                let _field_0 = <Box<QualifiedRule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<QualifiedRule> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Rule::QualifiedRule { 0: _field_0 }
             }
             Rule::AtRule { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Rule(self::fields::RuleField::AtRule));
-                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Rule::AtRule { 0: _field_0 }
             }
             Rule::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Rule(
-                    self::fields::RuleField::ListOfComponentValues,
-                ));
                 let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Rule::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ScopeRange {
-    #[doc = "Calls [FoldAstPath`::fold_scope_range`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_scope_range(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ScopeRange {
+    #[doc = "Calls [Fold`::fold_scope_range`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_scope_range(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ScopeRange {
                 span,
                 scope_start,
                 scope_end,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
-                        self::fields::ScopeRangeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 let scope_start = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
-                        self::fields::ScopeRangeField::ScopeStart,
-                    ));
-                    <Option<ForgivingSelectorList> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        scope_start,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ForgivingSelectorList> as FoldWith<V>>::fold_with(scope_start, visitor)
                 };
                 let scope_end = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
-                        self::fields::ScopeRangeField::ScopeEnd,
-                    ));
-                    <Option<ForgivingSelectorList> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        scope_end,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ForgivingSelectorList> as FoldWith<V>>::fold_with(scope_end, visitor)
                 };
                 ScopeRange {
                     span,
@@ -106238,298 +83992,139 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ScopeRange {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SelectorList {
-    #[doc = "Calls [FoldAstPath`::fold_selector_list`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_selector_list(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SelectorList {
+    #[doc = "Calls [Fold`::fold_selector_list`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_selector_list(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SelectorList { span, children } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
-                        self::fields::SelectorListField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let children = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
-                        self::fields::SelectorListField::Children(usize::MAX),
-                    ));
-                    <Vec<ComplexSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let children =
+                    { <Vec<ComplexSelector> as FoldWith<V>>::fold_with(children, visitor) };
                 SelectorList { span, children }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SequenceOfCustomIdents {
-    #[doc = "Calls [FoldAstPath`::fold_sequence_of_custom_idents`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_sequence_of_custom_idents(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            SequenceOfCustomIdents { span, value } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
-                            self::fields::SequenceOfCustomIdentsField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
-                            self::fields::SequenceOfCustomIdentsField::Value(usize::MAX),
-                        ));
-                    <Vec<CustomIdent> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                SequenceOfCustomIdents { span, value }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SimpleBlock {
-    #[doc = "Calls [FoldAstPath`::fold_simple_block`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_simple_block(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            SimpleBlock { span, name, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
-                        self::fields::SimpleBlockField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
-                        self::fields::SimpleBlockField::Name,
-                    ));
-                    <TokenAndSpan as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
-                        self::fields::SimpleBlockField::Value(usize::MAX),
-                    ));
-                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+impl<V: ?Sized + Fold> FoldWith<V> for SequenceOfCustomIdents {
+    #[doc = "Calls [Fold`::fold_sequence_of_custom_idents`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_sequence_of_custom_idents(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            SequenceOfCustomIdents { span, value } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Vec<CustomIdent> as FoldWith<V>>::fold_with(value, visitor) };
+                SequenceOfCustomIdents { span, value }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for SimpleBlock {
+    #[doc = "Calls [Fold`::fold_simple_block`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_simple_block(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            SimpleBlock { span, name, value } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <TokenAndSpan as FoldWith<V>>::fold_with(name, visitor) };
+                let value = { <Vec<ComponentValue> as FoldWith<V>>::fold_with(value, visitor) };
                 SimpleBlock { span, name, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeature {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeature {
+    #[doc = "Calls [Fold`::fold_size_feature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeature::Plain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::Plain,
-                ));
-                let _field_0 = <SizeFeaturePlain as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SizeFeaturePlain as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeature::Plain { 0: _field_0 }
             }
             SizeFeature::Boolean { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::Boolean,
-                ));
-                let _field_0 = <SizeFeatureBoolean as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SizeFeatureBoolean as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeature::Boolean { 0: _field_0 }
             }
             SizeFeature::Range { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::Range,
-                ));
-                let _field_0 = <SizeFeatureRange as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SizeFeatureRange as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeature::Range { 0: _field_0 }
             }
             SizeFeature::RangeInterval { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
-                    self::fields::SizeFeatureField::RangeInterval,
-                ));
-                let _field_0 = <SizeFeatureRangeInterval as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <SizeFeatureRangeInterval as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeature::RangeInterval { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureBoolean {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature_boolean`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature_boolean(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureBoolean {
+    #[doc = "Calls [Fold`::fold_size_feature_boolean`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature_boolean(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeatureBoolean { span, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
-                        self::fields::SizeFeatureBooleanField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
-                        self::fields::SizeFeatureBooleanField::Name,
-                    ));
-                    <SizeFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <SizeFeatureName as FoldWith<V>>::fold_with(name, visitor) };
                 SizeFeatureBoolean { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureName {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureName {
+    #[doc = "Calls [Fold`::fold_size_feature_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeatureName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureName(
-                    self::fields::SizeFeatureNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeatureName::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeaturePlain {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature_plain`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature_plain(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeaturePlain {
+    #[doc = "Calls [Fold`::fold_size_feature_plain`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature_plain(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeaturePlain { span, name, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
-                        self::fields::SizeFeaturePlainField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
-                        self::fields::SizeFeaturePlainField::Name,
-                    ));
-                    <SizeFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
-                        self::fields::SizeFeaturePlainField::Value,
-                    ));
-                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <SizeFeatureName as FoldWith<V>>::fold_with(name, visitor) };
+                let value = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(value, visitor) };
                 SizeFeaturePlain { span, name, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRange {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature_range`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature_range(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRange {
+    #[doc = "Calls [Fold`::fold_size_feature_range`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature_range(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeatureRange {
                 span,
@@ -106537,46 +84132,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRange {
                 comparison,
                 right,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Left,
-                    ));
-                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let comparison = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Comparison,
-                    ));
-                    <SizeFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
-                        comparison,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
-                        self::fields::SizeFeatureRangeField::Right,
-                    ));
-                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
+                let comparison =
+                    { <SizeFeatureRangeComparison as FoldWith<V>>::fold_with(comparison, visitor) };
+                let right = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
                 SizeFeatureRange {
                     span,
                     left,
@@ -106587,15 +84147,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRange {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRangeComparison {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature_range_comparison`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature_range_comparison(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRangeComparison {
+    #[doc = "Calls [Fold`::fold_size_feature_range_comparison`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature_range_comparison(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeatureRangeComparison::Lt => SizeFeatureRangeComparison::Lt,
             SizeFeatureRangeComparison::Le => SizeFeatureRangeComparison::Le,
@@ -106605,15 +84163,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRangeComparison
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRangeInterval {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature_range_interval`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature_range_interval(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureRangeInterval {
+    #[doc = "Calls [Fold`::fold_size_feature_range_interval`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature_range_interval(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeatureRangeInterval {
                 span,
@@ -106623,72 +84179,19 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRangeInterval {
                 right_comparison,
                 right,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Left,
-                        ));
-                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(left, visitor) };
                 let left_comparison = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::LeftComparison,
-                        ));
-                    <SizeFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left_comparison,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Name,
-                        ));
-                    <SizeFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SizeFeatureRangeComparison as FoldWith<V>>::fold_with(left_comparison, visitor)
                 };
+                let name = { <SizeFeatureName as FoldWith<V>>::fold_with(name, visitor) };
                 let right_comparison = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::RightComparison,
-                        ));
-                    <SizeFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
+                    <SizeFeatureRangeComparison as FoldWith<V>>::fold_with(
                         right_comparison,
                         visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
-                            self::fields::SizeFeatureRangeIntervalField::Right,
-                        ));
-                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
                     )
                 };
+                let right = { <Box<SizeFeatureValue> as FoldWith<V>>::fold_with(right, visitor) };
                 SizeFeatureRangeInterval {
                     span,
                     left,
@@ -106701,324 +84204,147 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRangeInterval {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureValue {
-    #[doc = "Calls [FoldAstPath`::fold_size_feature_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_size_feature_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SizeFeatureValue {
+    #[doc = "Calls [Fold`::fold_size_feature_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_size_feature_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SizeFeatureValue::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Number,
-                ));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeatureValue::Number { 0: _field_0 }
             }
             SizeFeatureValue::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Dimension,
-                ));
-                let _field_0 = <Dimension as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Dimension as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeatureValue::Dimension { 0: _field_0 }
             }
             SizeFeatureValue::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeatureValue::Ident { 0: _field_0 }
             }
             SizeFeatureValue::Ratio { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Ratio,
-                ));
-                let _field_0 = <Ratio as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ratio as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeatureValue::Ratio { 0: _field_0 }
             }
             SizeFeatureValue::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
-                    self::fields::SizeFeatureValueField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 SizeFeatureValue::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Str {
-    #[doc = "Calls [FoldAstPath`::fold_str`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_str(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Str {
+    #[doc = "Calls [Fold`::fold_str`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_str(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Str { span, value, raw } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 Str { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for StyleBlock {
-    #[doc = "Calls [FoldAstPath`::fold_style_block`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_style_block(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for StyleBlock {
+    #[doc = "Calls [Fold`::fold_style_block`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_style_block(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             StyleBlock::AtRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::AtRule,
-                ));
-                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<AtRule> as FoldWith<V>>::fold_with(_field_0, visitor);
                 StyleBlock::AtRule { 0: _field_0 }
             }
             StyleBlock::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::Declaration,
-                ));
-                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
                 StyleBlock::Declaration { 0: _field_0 }
             }
             StyleBlock::QualifiedRule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::QualifiedRule,
-                ));
-                let _field_0 = <Box<QualifiedRule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<QualifiedRule> as FoldWith<V>>::fold_with(_field_0, visitor);
                 StyleBlock::QualifiedRule { 0: _field_0 }
             }
             StyleBlock::ListOfComponentValues { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
-                    self::fields::StyleBlockField::ListOfComponentValues,
-                ));
                 let _field_0 =
-                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <Box<ListOfComponentValues> as FoldWith<V>>::fold_with(_field_0, visitor);
                 StyleBlock::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Stylesheet {
-    #[doc = "Calls [FoldAstPath`::fold_stylesheet`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_stylesheet(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Stylesheet {
+    #[doc = "Calls [Fold`::fold_stylesheet`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_stylesheet(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Stylesheet { span, rules } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
-                        self::fields::StylesheetField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let rules = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
-                        self::fields::StylesheetField::Rules(usize::MAX),
-                    ));
-                    <Vec<Rule> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        rules,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                Stylesheet { span, rules }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SubclassSelector {
-    #[doc = "Calls [FoldAstPath`::fold_subclass_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_subclass_selector(visitor, self, __ast_path)
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let rules = { <Vec<Rule> as FoldWith<V>>::fold_with(rules, visitor) };
+                Stylesheet { span, rules }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for SubclassSelector {
+    #[doc = "Calls [Fold`::fold_subclass_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_subclass_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SubclassSelector::Id { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::Id,
-                ));
-                let _field_0 = <IdSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <IdSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 SubclassSelector::Id { 0: _field_0 }
             }
             SubclassSelector::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::Class,
-                ));
-                let _field_0 = <ClassSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ClassSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 SubclassSelector::Class { 0: _field_0 }
             }
             SubclassSelector::Attribute { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::Attribute,
-                ));
-                let _field_0 = <Box<AttributeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <Box<AttributeSelector> as FoldWith<V>>::fold_with(_field_0, visitor);
                 SubclassSelector::Attribute { 0: _field_0 }
             }
             SubclassSelector::PseudoClass { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::PseudoClass,
-                ));
-                let _field_0 = <PseudoClassSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PseudoClassSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 SubclassSelector::PseudoClass { 0: _field_0 }
             }
             SubclassSelector::PseudoElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
-                    self::fields::SubclassSelectorField::PseudoElement,
-                ));
-                let _field_0 = <PseudoElementSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PseudoElementSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 SubclassSelector::PseudoElement { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsAnd {
-    #[doc = "Calls [FoldAstPath`::fold_supports_and`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_and(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SupportsAnd {
+    #[doc = "Calls [Fold`::fold_supports_and`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_and(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SupportsAnd {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
-                        self::fields::SupportsAndField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
-                        self::fields::SupportsAndField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let condition = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
-                        self::fields::SupportsAndField::Condition,
-                    ));
-                    <Box<SupportsInParens> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let condition =
+                    { <Box<SupportsInParens> as FoldWith<V>>::fold_with(condition, visitor) };
                 SupportsAnd {
                     span,
                     keyword,
@@ -107028,225 +84354,109 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsAnd {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsCondition {
-    #[doc = "Calls [FoldAstPath`::fold_supports_condition`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_condition(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SupportsCondition {
+    #[doc = "Calls [Fold`::fold_supports_condition`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_condition(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SupportsCondition { span, conditions } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
-                        self::fields::SupportsConditionField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let conditions = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
-                        self::fields::SupportsConditionField::Conditions(usize::MAX),
-                    ));
-                    <Vec<SupportsConditionType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        conditions,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let conditions =
+                    { <Vec<SupportsConditionType> as FoldWith<V>>::fold_with(conditions, visitor) };
                 SupportsCondition { span, conditions }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsConditionType {
-    #[doc = "Calls [FoldAstPath`::fold_supports_condition_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_condition_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SupportsConditionType {
+    #[doc = "Calls [Fold`::fold_supports_condition_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_condition_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SupportsConditionType::Not { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::Not,
-                ));
-                let _field_0 = <SupportsNot as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SupportsNot as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsConditionType::Not { 0: _field_0 }
             }
             SupportsConditionType::And { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::And,
-                ));
-                let _field_0 = <SupportsAnd as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SupportsAnd as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsConditionType::And { 0: _field_0 }
             }
             SupportsConditionType::Or { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::Or,
-                ));
-                let _field_0 = <SupportsOr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SupportsOr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsConditionType::Or { 0: _field_0 }
             }
             SupportsConditionType::SupportsInParens { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
-                    self::fields::SupportsConditionTypeField::SupportsInParens,
-                ));
-                let _field_0 = <SupportsInParens as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SupportsInParens as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsConditionType::SupportsInParens { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsFeature {
-    #[doc = "Calls [FoldAstPath`::fold_supports_feature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_feature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SupportsFeature {
+    #[doc = "Calls [Fold`::fold_supports_feature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_feature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SupportsFeature::Declaration { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
-                    self::fields::SupportsFeatureField::Declaration,
-                ));
-                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Declaration> as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsFeature::Declaration { 0: _field_0 }
             }
             SupportsFeature::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
-                    self::fields::SupportsFeatureField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsFeature::Function { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsInParens {
-    #[doc = "Calls [FoldAstPath`::fold_supports_in_parens`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_in_parens(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SupportsInParens {
+    #[doc = "Calls [Fold`::fold_supports_in_parens`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_in_parens(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SupportsInParens::SupportsCondition { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
-                    self::fields::SupportsInParensField::SupportsCondition,
-                ));
-                let _field_0 = <SupportsCondition as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SupportsCondition as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsInParens::SupportsCondition { 0: _field_0 }
             }
             SupportsInParens::Feature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
-                    self::fields::SupportsInParensField::Feature,
-                ));
-                let _field_0 = <SupportsFeature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SupportsFeature as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsInParens::Feature { 0: _field_0 }
             }
             SupportsInParens::GeneralEnclosed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
-                    self::fields::SupportsInParensField::GeneralEnclosed,
-                ));
-                let _field_0 = <GeneralEnclosed as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <GeneralEnclosed as FoldWith<V>>::fold_with(_field_0, visitor);
                 SupportsInParens::GeneralEnclosed { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsNot {
-    #[doc = "Calls [FoldAstPath`::fold_supports_not`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_not(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SupportsNot {
+    #[doc = "Calls [Fold`::fold_supports_not`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_not(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SupportsNot {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
-                        self::fields::SupportsNotField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
-                        self::fields::SupportsNotField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let condition = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
-                        self::fields::SupportsNotField::Condition,
-                    ));
-                    <Box<SupportsInParens> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let condition =
+                    { <Box<SupportsInParens> as FoldWith<V>>::fold_with(condition, visitor) };
                 SupportsNot {
                     span,
                     keyword,
@@ -107256,51 +84466,23 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsNot {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsOr {
-    #[doc = "Calls [FoldAstPath`::fold_supports_or`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_or(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SupportsOr {
+    #[doc = "Calls [Fold`::fold_supports_or`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_or(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SupportsOr {
                 span,
                 keyword,
                 condition,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
-                        self::fields::SupportsOrField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let keyword = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
-                        self::fields::SupportsOrField::Keyword,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        keyword,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let condition = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
-                        self::fields::SupportsOrField::Condition,
-                    ));
-                    <Box<SupportsInParens> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        condition,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let keyword = { <Option<Ident> as FoldWith<V>>::fold_with(keyword, visitor) };
+                let condition =
+                    { <Box<SupportsInParens> as FoldWith<V>>::fold_with(condition, visitor) };
                 SupportsOr {
                     span,
                     keyword,
@@ -107310,326 +84492,112 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsOr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TagNameSelector {
-    #[doc = "Calls [FoldAstPath`::fold_tag_name_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_tag_name_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TagNameSelector {
+    #[doc = "Calls [Fold`::fold_tag_name_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_tag_name_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TagNameSelector { span, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
-                        self::fields::TagNameSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
-                        self::fields::TagNameSelectorField::Name,
-                    ));
-                    <WqName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <WqName as FoldWith<V>>::fold_with(name, visitor) };
                 TagNameSelector { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Time {
-    #[doc = "Calls [FoldAstPath`::fold_time`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_time(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Time {
+    #[doc = "Calls [Fold`::fold_time`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_time(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Time { span, value, unit } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Value));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Unit));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
+                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
                 Time { span, value, unit }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TimePercentage {
-    #[doc = "Calls [FoldAstPath`::fold_time_percentage`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_time_percentage(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TimePercentage {
+    #[doc = "Calls [Fold`::fold_time_percentage`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_time_percentage(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TimePercentage::Time { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
-                    self::fields::TimePercentageField::Time,
-                ));
-                let _field_0 = <Time as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Time as FoldWith<V>>::fold_with(_field_0, visitor);
                 TimePercentage::Time { 0: _field_0 }
             }
             TimePercentage::Percentage { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
-                    self::fields::TimePercentageField::Percentage,
-                ));
-                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                TimePercentage::Percentage { 0: _field_0 }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Token {
-    #[doc = "Calls [FoldAstPath`::fold_token`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_token(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            Token::Ident { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Ident));
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                Token::Ident { value, raw }
-            }
-            Token::Function { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Function));
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let _field_0 = <Percentage as FoldWith<V>>::fold_with(_field_0, visitor);
+                TimePercentage::Percentage { 0: _field_0 }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for Token {
+    #[doc = "Calls [Fold`::fold_token`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_token(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            Token::Ident { value, raw } => {
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
+                Token::Ident { value, raw }
+            }
+            Token::Function { value, raw } => {
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::Function { value, raw }
             }
             Token::AtKeyword { value, raw } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::AtKeyword));
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::AtKeyword { value, raw }
             }
             Token::Hash { is_id, value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Hash));
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::Hash { is_id, value, raw }
             }
             Token::String { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::String));
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::String { value, raw }
             }
             Token::BadString { raw } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::BadString));
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::BadString { raw }
             }
             Token::Url { value, raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Url));
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <Box<UrlKeyValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Box<UrlKeyValue> as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::Url { value, raw }
             }
             Token::BadUrl { raw } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::BadUrl));
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::BadUrl { raw }
             }
-            Token::Delim { value } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Delim));
-                Token::Delim { value }
-            }
+            Token::Delim { value } => Token::Delim { value },
             Token::Number {
                 value,
                 raw,
                 type_flag,
             } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Number));
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_flag = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::TypeFlag));
-                    <NumberType as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_flag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
+                let type_flag = { <NumberType as FoldWith<V>>::fold_with(type_flag, visitor) };
                 Token::Number {
                     value,
                     raw,
@@ -107637,41 +84605,15 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Token {
                 }
             }
             Token::Percentage { value, raw } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::Percentage));
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 Token::Percentage { value, raw }
             }
             Token::Dimension { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::Dimension));
-                let _field_0 = <Box<DimensionToken> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<DimensionToken> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Token::Dimension { 0: _field_0 }
             }
             Token::WhiteSpace { value } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Token(self::fields::TokenField::WhiteSpace));
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
                 Token::WhiteSpace { value }
             }
             Token::CDO => Token::CDO,
@@ -107688,86 +84630,48 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Token {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TokenAndSpan {
-    #[doc = "Calls [FoldAstPath`::fold_token_and_span`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_token_and_span(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TokenAndSpan {
+    #[doc = "Calls [Fold`::fold_token_and_span`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_token_and_span(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TokenAndSpan { span, token } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
-                        self::fields::TokenAndSpanField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let token = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
-                        self::fields::TokenAndSpanField::Token,
-                    ));
-                    <Token as FoldWithAstPath<V>>::fold_with_ast_path(
-                        token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let token = { <Token as FoldWith<V>>::fold_with(token, visitor) };
                 TokenAndSpan { span, token }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TypeSelector {
-    #[doc = "Calls [FoldAstPath`::fold_type_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_type_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TypeSelector {
+    #[doc = "Calls [Fold`::fold_type_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_type_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TypeSelector::TagName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
-                    self::fields::TypeSelectorField::TagName,
-                ));
-                let _field_0 = <TagNameSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TagNameSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 TypeSelector::TagName { 0: _field_0 }
             }
             TypeSelector::Universal { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
-                    self::fields::TypeSelectorField::Universal,
-                ));
-                let _field_0 = <UniversalSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <UniversalSelector as FoldWith<V>>::fold_with(_field_0, visitor);
                 TypeSelector::Universal { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnicodeRange {
-    #[doc = "Calls [FoldAstPath`::fold_unicode_range`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_unicode_range(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UnicodeRange {
+    #[doc = "Calls [Fold`::fold_unicode_range`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_unicode_range(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UnicodeRange {
                 span,
@@ -107775,46 +84679,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnicodeRange {
                 end,
                 raw,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let start = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::Start,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        start,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let end = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::End,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        end,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
-                        self::fields::UnicodeRangeField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let start = { <swc_atoms::Atom as FoldWith<V>>::fold_with(start, visitor) };
+                let end = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(end, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 UnicodeRange {
                     span,
                     start,
@@ -107825,97 +84693,47 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnicodeRange {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UniversalSelector {
-    #[doc = "Calls [FoldAstPath`::fold_universal_selector`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_universal_selector(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UniversalSelector {
+    #[doc = "Calls [Fold`::fold_universal_selector`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_universal_selector(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UniversalSelector { span, prefix } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
-                        self::fields::UniversalSelectorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prefix = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
-                        self::fields::UniversalSelectorField::Prefix,
-                    ));
-                    <Option<NamespacePrefix> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let prefix =
+                    { <Option<NamespacePrefix> as FoldWith<V>>::fold_with(prefix, visitor) };
                 UniversalSelector { span, prefix }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnknownDimension {
-    #[doc = "Calls [FoldAstPath`::fold_unknown_dimension`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_unknown_dimension(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UnknownDimension {
+    #[doc = "Calls [Fold`::fold_unknown_dimension`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_unknown_dimension(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UnknownDimension { span, value, unit } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
-                        self::fields::UnknownDimensionField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
-                        self::fields::UnknownDimensionField::Value,
-                    ));
-                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let unit = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
-                        self::fields::UnknownDimensionField::Unit,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        unit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Number as FoldWith<V>>::fold_with(value, visitor) };
+                let unit = { <Ident as FoldWith<V>>::fold_with(unit, visitor) };
                 UnknownDimension { span, value, unit }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Url {
-    #[doc = "Calls [FoldAstPath`::fold_url`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_url(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Url {
+    #[doc = "Calls [Fold`::fold_url`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_url(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Url {
                 span,
@@ -107923,43 +84741,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Url {
                 value,
                 modifiers,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Name));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Value));
-                    <Option<Box<UrlValue>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let modifiers = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Url(
-                        self::fields::UrlField::Modifiers(usize::MAX),
-                    ));
-                    <Option<Vec<UrlModifier>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        modifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
+                let value = { <Option<Box<UrlValue>> as FoldWith<V>>::fold_with(value, visitor) };
+                let modifiers =
+                    { <Option<Vec<UrlModifier>> as FoldWith<V>>::fold_with(modifiers, visitor) };
                 Url {
                     span,
                     name,
@@ -107970,30 +84756,20 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Url {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlKeyValue {
-    #[doc = "Calls [FoldAstPath`::fold_url_key_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_url_key_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UrlKeyValue {
+    #[doc = "Calls [Fold`::fold_url_key_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_url_key_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UrlKeyValue {
                 0: _field_0,
                 1: _field_1,
             } => {
-                let _field_0 = <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                let _field_1 = <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_1,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <swc_atoms::Atom as FoldWith<V>>::fold_with(_field_0, visitor);
+                let _field_1 = <swc_atoms::Atom as FoldWith<V>>::fold_with(_field_1, visitor);
                 UrlKeyValue {
                     0: _field_0,
                     1: _field_1,
@@ -108002,162 +84778,78 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlKeyValue {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlModifier {
-    #[doc = "Calls [FoldAstPath`::fold_url_modifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_url_modifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UrlModifier {
+    #[doc = "Calls [Fold`::fold_url_modifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_url_modifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UrlModifier::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
-                    self::fields::UrlModifierField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 UrlModifier::Ident { 0: _field_0 }
             }
             UrlModifier::Function { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
-                    self::fields::UrlModifierField::Function,
-                ));
-                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                UrlModifier::Function { 0: _field_0 }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlValue {
-    #[doc = "Calls [FoldAstPath`::fold_url_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_url_value(visitor, self, __ast_path)
+                let _field_0 = <Function as FoldWith<V>>::fold_with(_field_0, visitor);
+                UrlModifier::Function { 0: _field_0 }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for UrlValue {
+    #[doc = "Calls [Fold`::fold_url_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_url_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UrlValue::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Str));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 UrlValue::Str { 0: _field_0 }
             }
             UrlValue::Raw { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Raw));
-                let _field_0 = <UrlValueRaw as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <UrlValueRaw as FoldWith<V>>::fold_with(_field_0, visitor);
                 UrlValue::Raw { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlValueRaw {
-    #[doc = "Calls [FoldAstPath`::fold_url_value_raw`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_url_value_raw(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UrlValueRaw {
+    #[doc = "Calls [Fold`::fold_url_value_raw`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_url_value_raw(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UrlValueRaw { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
-                        self::fields::UrlValueRawField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
-                        self::fields::UrlValueRawField::Value,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
-                        self::fields::UrlValueRawField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 UrlValueRaw { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WqName {
-    #[doc = "Calls [FoldAstPath`::fold_wq_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_wq_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for WqName {
+    #[doc = "Calls [Fold`::fold_wq_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_wq_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             WqName {
                 span,
                 prefix,
                 value,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prefix = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Prefix));
-                    <Option<NamespacePrefix> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prefix,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Value));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let prefix =
+                    { <Option<NamespacePrefix> as FoldWith<V>>::fold_with(prefix, visitor) };
+                let value = { <Ident as FoldWith<V>>::fold_with(value, visitor) };
                 WqName {
                     span,
                     prefix,
@@ -108167,9203 +84859,13657 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WqName {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
-    #[doc = "Calls [FoldAstPath`::fold_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
+    #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_atom(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CalcProductOrOperator> {
-    #[doc = "Calls [FoldAstPath`::fold_calc_product_or_operators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<CalcProductOrOperator> {
+    #[doc = "Calls [Fold`::fold_calc_product_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_product_or_operators(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_product_or_operators(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <CalcProductOrOperator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <CalcProductOrOperator as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CalcValueOrOperator> {
-    #[doc = "Calls [FoldAstPath`::fold_calc_value_or_operators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<CalcValueOrOperator> {
+    #[doc = "Calls [Fold`::fold_calc_value_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_calc_value_or_operators(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_calc_value_or_operators(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <CalcValueOrOperator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <CalcValueOrOperator as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComplexSelectorChildren> {
-    #[doc = "Calls [FoldAstPath`::fold_complex_selector_childrens`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelectorChildren> {
+    #[doc = "Calls [Fold`::fold_complex_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_complex_selector_childrens(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_complex_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ComplexSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ComplexSelectorChildren as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComplexSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_complex_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelector> {
+    #[doc = "Calls [Fold`::fold_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_complex_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_complex_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ComplexSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComponentValue> {
-    #[doc = "Calls [FoldAstPath`::fold_component_values`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComponentValue> {
+    #[doc = "Calls [Fold`::fold_component_values`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_component_values(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_component_values(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ComponentValue as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ComponentValue as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CompoundSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_compound_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<CompoundSelector> {
+    #[doc = "Calls [Fold`::fold_compound_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_compound_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_compound_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <CompoundSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ContainerQueryType> {
-    #[doc = "Calls [FoldAstPath`::fold_container_query_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ContainerQueryType> {
+    #[doc = "Calls [Fold`::fold_container_query_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_container_query_types(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_container_query_types(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ContainerQueryType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ContainerQueryType as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CustomIdent> {
-    #[doc = "Calls [FoldAstPath`::fold_custom_idents`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<CustomIdent> {
+    #[doc = "Calls [Fold`::fold_custom_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_custom_idents(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_custom_idents(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <CustomIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <CustomIdent as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<DocumentPreludeMatchingFunction> {
-    #[doc = "Calls [FoldAstPath`::fold_document_prelude_matching_functions`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<DocumentPreludeMatchingFunction> {
+    #[doc = "Calls [Fold`::fold_document_prelude_matching_functions`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_document_prelude_matching_functions(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_document_prelude_matching_functions(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <DocumentPreludeMatchingFunction as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <DocumentPreludeMatchingFunction as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<FamilyName> {
-    #[doc = "Calls [FoldAstPath`::fold_family_names`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<FamilyName> {
+    #[doc = "Calls [Fold`::fold_family_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_family_names(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_family_names(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <FamilyName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <FamilyName as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ForgivingComplexSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_forgiving_complex_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingComplexSelector> {
+    #[doc = "Calls [Fold`::fold_forgiving_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_forgiving_complex_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_forgiving_complex_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ForgivingComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ForgivingComplexSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ForgivingRelativeSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_forgiving_relative_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingRelativeSelector> {
+    #[doc = "Calls [Fold`::fold_forgiving_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_forgiving_relative_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_forgiving_relative_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ForgivingRelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ForgivingRelativeSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Ident> {
-    #[doc = "Calls [FoldAstPath`::fold_idents`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Ident> {
+    #[doc = "Calls [Fold`::fold_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_idents(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_idents(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Ident as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Ident as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<KeyframeSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_keyframe_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<KeyframeSelector> {
+    #[doc = "Calls [Fold`::fold_keyframe_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_keyframe_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_keyframe_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <KeyframeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <KeyframeSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<LayerName> {
-    #[doc = "Calls [FoldAstPath`::fold_layer_names`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<LayerName> {
+    #[doc = "Calls [Fold`::fold_layer_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_layer_names(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_layer_names(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <LayerName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <LayerName as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaConditionAllType> {
-    #[doc = "Calls [FoldAstPath`::fold_media_condition_all_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaConditionAllType> {
+    #[doc = "Calls [Fold`::fold_media_condition_all_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_condition_all_types(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_condition_all_types(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <MediaConditionAllType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <MediaConditionAllType as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaConditionWithoutOrType> {
-    #[doc = "Calls [FoldAstPath`::fold_media_condition_without_or_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaConditionWithoutOrType> {
+    #[doc = "Calls [Fold`::fold_media_condition_without_or_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_condition_without_or_types(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_condition_without_or_types(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <MediaConditionWithoutOrType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <MediaConditionWithoutOrType as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaQuery> {
-    #[doc = "Calls [FoldAstPath`::fold_media_querys`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaQuery> {
+    #[doc = "Calls [Fold`::fold_media_querys`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_media_querys(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_media_querys(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <MediaQuery as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <MediaQuery as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<AtRulePrelude>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_at_rule_prelude`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<AtRulePrelude>> {
+    #[doc = "Calls [Fold`::fold_opt_at_rule_prelude`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_at_rule_prelude(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_at_rule_prelude(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<AtRulePrelude> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<AtRulePrelude> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [Fold`::fold_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_atom(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_atom(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorMatcher> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<AttributeSelectorMatcher> {
+    #[doc = "Calls [Fold`::fold_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_attribute_selector_matcher(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_attribute_selector_matcher(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <AttributeSelectorMatcher as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <AttributeSelectorMatcher as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorModifier> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<AttributeSelectorModifier> {
+    #[doc = "Calls [Fold`::fold_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_attribute_selector_modifier(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_attribute_selector_modifier(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <AttributeSelectorModifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <AttributeSelectorModifier as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorValue> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_attribute_selector_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<AttributeSelectorValue> {
+    #[doc = "Calls [Fold`::fold_opt_attribute_selector_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_attribute_selector_value(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_attribute_selector_value(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <AttributeSelectorValue as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <AttributeSelectorValue as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Combinator> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_combinator`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Combinator> {
+    #[doc = "Calls [Fold`::fold_opt_combinator`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_combinator(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_combinator(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Combinator as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Combinator as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ContainerName> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_container_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<ContainerName> {
+    #[doc = "Calls [Fold`::fold_opt_container_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_container_name(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_container_name(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <ContainerName as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <ContainerName as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ForgivingSelectorList> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<ForgivingSelectorList> {
+    #[doc = "Calls [Fold`::fold_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_forgiving_selector_list(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_forgiving_selector_list(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <ForgivingSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <ForgivingSelectorList as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Function>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_function`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Function>> {
+    #[doc = "Calls [Fold`::fold_opt_function`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_function(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_function(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<Function> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Ident> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ident`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Ident> {
+    #[doc = "Calls [Fold`::fold_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ident(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ident(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Ident as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Ident as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ImportConditions>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_import_conditions`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<ImportConditions>> {
+    #[doc = "Calls [Fold`::fold_opt_import_conditions`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_import_conditions(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_import_conditions(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<ImportConditions> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<ImportConditions> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ImportLayerName>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_import_layer_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<ImportLayerName>> {
+    #[doc = "Calls [Fold`::fold_opt_import_layer_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_import_layer_name(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_import_layer_name(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<ImportLayerName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<ImportLayerName> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ImportantFlag> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_important_flag`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<ImportantFlag> {
+    #[doc = "Calls [Fold`::fold_opt_important_flag`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_important_flag(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_important_flag(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <ImportantFlag as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <ImportantFlag as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<MediaConditionType>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_media_condition_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<MediaConditionType>> {
+    #[doc = "Calls [Fold`::fold_opt_media_condition_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_media_condition_type(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_media_condition_type(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<MediaConditionType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<MediaConditionType> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<MediaQueryList>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_media_query_list`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<MediaQueryList>> {
+    #[doc = "Calls [Fold`::fold_opt_media_query_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_media_query_list(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_media_query_list(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<MediaQueryList> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<MediaQueryList> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<MediaType> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_media_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<MediaType> {
+    #[doc = "Calls [Fold`::fold_opt_media_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_media_type(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_media_type(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <MediaType as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <MediaType as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Namespace> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_namespace`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Namespace> {
+    #[doc = "Calls [Fold`::fold_opt_namespace`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_namespace(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_namespace(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Namespace as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Namespace as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<NamespacePrefix> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_namespace_prefix`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<NamespacePrefix> {
+    #[doc = "Calls [Fold`::fold_opt_namespace_prefix`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_namespace_prefix(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_namespace_prefix(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <NamespacePrefix as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <NamespacePrefix as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<NestingSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_nesting_selector`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<NestingSelector> {
+    #[doc = "Calls [Fold`::fold_opt_nesting_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_nesting_selector(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_nesting_selector(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <NestingSelector as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <NestingSelector as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Number> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_number`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Number> {
+    #[doc = "Calls [Fold`::fold_opt_number`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_number(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_number(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Number as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Number as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PageSelectorPseudo>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PageSelectorPseudo>> {
+    #[doc = "Calls [Fold`::fold_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_page_selector_pseudos(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_page_selector_pseudos(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Vec<PageSelectorPseudo> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Vec<PageSelectorPseudo> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<PageSelectorType> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_page_selector_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<PageSelectorType> {
+    #[doc = "Calls [Fold`::fold_opt_page_selector_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_page_selector_type(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_page_selector_type(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <PageSelectorType as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <PageSelectorType as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PseudoClassSelectorChildren>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
+    #[doc = "Calls [Fold`::fold_opt_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_pseudo_class_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| {
-            <Vec<PseudoClassSelectorChildren> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
+            <Vec<PseudoClassSelectorChildren> as FoldWith<V>>::fold_with(inner, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PseudoElementSelectorChildren>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_pseudo_element_selector_childrens`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
+    #[doc = "Calls [Fold`::fold_opt_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_pseudo_element_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| {
-            <Vec<PseudoElementSelectorChildren> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
+            <Vec<PseudoElementSelectorChildren> as FoldWith<V>>::fold_with(inner, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<SimpleBlock> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_simple_block`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<SimpleBlock> {
+    #[doc = "Calls [Fold`::fold_opt_simple_block`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_simple_block(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_simple_block(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <SimpleBlock as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TypeSelector>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_type_selector`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TypeSelector>> {
+    #[doc = "Calls [Fold`::fold_opt_type_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_type_selector(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_type_selector(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<TypeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<TypeSelector> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<UrlModifier>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_url_modifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<UrlModifier>> {
+    #[doc = "Calls [Fold`::fold_opt_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_url_modifiers(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_url_modifiers(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Vec<UrlModifier> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Vec<UrlModifier> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<UrlValue>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_url_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<UrlValue>> {
+    #[doc = "Calls [Fold`::fold_opt_url_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_url_value(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_url_value(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<UrlValue> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<UrlValue> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PageSelectorPseudo> {
-    #[doc = "Calls [FoldAstPath`::fold_page_selector_pseudos`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelectorPseudo> {
+    #[doc = "Calls [Fold`::fold_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_page_selector_pseudos(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_page_selector_pseudos(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <PageSelectorPseudo as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <PageSelectorPseudo as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PageSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_page_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelector> {
+    #[doc = "Calls [Fold`::fold_page_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_page_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_page_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <PageSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <PageSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PseudoClassSelectorChildren> {
-    #[doc = "Calls [FoldAstPath`::fold_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<PseudoClassSelectorChildren> {
+    #[doc = "Calls [Fold`::fold_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pseudo_class_selector_childrens(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pseudo_class_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <PseudoClassSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <PseudoClassSelectorChildren as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PseudoElementSelectorChildren> {
-    #[doc = "Calls [FoldAstPath`::fold_pseudo_element_selector_childrens`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<PseudoElementSelectorChildren> {
+    #[doc = "Calls [Fold`::fold_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pseudo_element_selector_childrens(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pseudo_element_selector_childrens(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <PseudoElementSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <PseudoElementSelectorChildren as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<RelativeSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_relative_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<RelativeSelector> {
+    #[doc = "Calls [Fold`::fold_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_relative_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_relative_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <RelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <RelativeSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Rule> {
-    #[doc = "Calls [FoldAstPath`::fold_rules`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Rule> {
+    #[doc = "Calls [Fold`::fold_rules`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_rules(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_rules(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Rule as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Rule as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::Span {
-    #[doc = "Calls [FoldAstPath`::fold_span`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
+    #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_span(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SubclassSelector> {
-    #[doc = "Calls [FoldAstPath`::fold_subclass_selectors`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<SubclassSelector> {
+    #[doc = "Calls [Fold`::fold_subclass_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_subclass_selectors(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_subclass_selectors(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <SubclassSelector as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <SubclassSelector as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SupportsConditionType> {
-    #[doc = "Calls [FoldAstPath`::fold_supports_condition_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<SupportsConditionType> {
+    #[doc = "Calls [Fold`::fold_supports_condition_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_supports_condition_types(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_supports_condition_types(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <SupportsConditionType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <SupportsConditionType as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<UrlModifier> {
-    #[doc = "Calls [FoldAstPath`::fold_url_modifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<UrlModifier> {
+    #[doc = "Calls [Fold`::fold_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_url_modifiers(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_url_modifiers(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <UrlModifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <UrlModifier as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> FoldWithAstPath<V> for std::boxed::Box<T>
+impl<V, T> FoldWith<V> for std::boxed::Box<T>
 where
-    V: ?Sized + FoldAstPath,
-    T: FoldWithAstPath<V>,
+    V: ?Sized + Fold,
+    T: FoldWith<V>,
 {
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        swc_visit::util::map::Map::map(self, |inner| {
-            <T as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::map::Map::map(self, |inner| <T as FoldWith<V>>::fold_with(inner, visitor))
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::map::Map::map(self, |inner| {
-            <T as FoldWithAstPath<V>>::fold_children_with_ast_path(inner, visitor, __ast_path)
+            <T as FoldWith<V>>::fold_children_with(inner, visitor)
         })
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-pub trait VisitAll {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait FoldAstPath {
     #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
-             [`AbsoluteColorBase::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AbsoluteColorBase::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
-        <AbsoluteColorBase as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_absolute_color_base(
+        &mut self,
+        node: AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) -> AbsoluteColorBase {
+        <AbsoluteColorBase as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
-             [`AlphaValue::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AlphaValue::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_alpha_value(&mut self, node: &AlphaValue) {
-        <AlphaValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
+        <AlphaValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
-             [`AnPlusB::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AnPlusB::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_an_plus_b(&mut self, node: &AnPlusB) {
-        <AnPlusB as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
+        <AnPlusB as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
-             [`AnPlusBNotation::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AnPlusBNotation::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
-        <AnPlusBNotation as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_an_plus_b_notation(
+        &mut self,
+        node: AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) -> AnPlusBNotation {
+        <AnPlusBNotation as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
-             [`Angle::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Angle::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_angle(&mut self, node: &Angle) {
-        <Angle as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
+        <Angle as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
-             [`AnglePercentage::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AnglePercentage::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
-        <AnglePercentage as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_angle_percentage(
+        &mut self,
+        node: AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> AnglePercentage {
+        <AnglePercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
-             [`AnyNamespace::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AnyNamespace::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_any_namespace(&mut self, node: &AnyNamespace) {
-        <AnyNamespace as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_any_namespace(
+        &mut self,
+        node: AnyNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> AnyNamespace {
+        <AnyNamespace as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
-             [`AtRule::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`AtRule::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_at_rule(&mut self, node: &AtRule) {
-        <AtRule as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
+        <AtRule as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
-             [`AtRuleName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AtRuleName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_at_rule_name(&mut self, node: &AtRuleName) {
-        <AtRuleName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
+        <AtRuleName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
-             [`AtRulePrelude::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AtRulePrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
-        <AtRulePrelude as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_at_rule_prelude(
+        &mut self,
+        node: AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> AtRulePrelude {
+        <AtRulePrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`swc_atoms :: Atom::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <swc_atoms::Atom as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
+        <swc_atoms::Atom as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
-             [`AttributeSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AttributeSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
-        <AttributeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_attribute_selector(
+        &mut self,
+        node: AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelector {
+        <AttributeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
-             [`AttributeSelectorMatcher::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AttributeSelectorMatcher::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
-        <AttributeSelectorMatcher as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_attribute_selector_matcher(
+        &mut self,
+        node: AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcher {
+        <AttributeSelectorMatcher as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
-             calls [`AttributeSelectorMatcherValue::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`AttributeSelectorMatcherValue::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_attribute_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
-        <AttributeSelectorMatcherValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_attribute_selector_matcher_value(
+        &mut self,
+        node: AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcherValue {
+        <AttributeSelectorMatcherValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
-             [`AttributeSelectorModifier::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AttributeSelectorModifier::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
-        <AttributeSelectorModifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_attribute_selector_modifier(
+        &mut self,
+        node: AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorModifier {
+        <AttributeSelectorModifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
-             [`AttributeSelectorValue::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AttributeSelectorValue::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
-        <AttributeSelectorValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_attribute_selector_value(
+        &mut self,
+        node: AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorValue {
+        <AttributeSelectorValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
-             [`BinOp::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`BinOp::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_bin_op(&mut self, node: &BinOp) {
-        <BinOp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
+        <BinOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
-             [`CalcOperator::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CalcOperator::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_calc_operator(&mut self, node: &CalcOperator) {
-        <CalcOperator as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_operator(
+        &mut self,
+        node: CalcOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperator {
+        <CalcOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
-             [`CalcOperatorType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CalcOperatorType::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
-        <CalcOperatorType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_operator_type(
+        &mut self,
+        node: CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperatorType {
+        <CalcOperatorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
-             [`CalcProduct::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CalcProduct::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_calc_product(&mut self, node: &CalcProduct) {
-        <CalcProduct as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_product(
+        &mut self,
+        node: CalcProduct,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProduct {
+        <CalcProduct as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
-             [`CalcProductOrOperator::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CalcProductOrOperator::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
-        <CalcProductOrOperator as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_product_or_operator(
+        &mut self,
+        node: CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProductOrOperator {
+        <CalcProductOrOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
-             calls [`Vec < CalcProductOrOperator >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Vec < CalcProductOrOperator >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
-        <[CalcProductOrOperator] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_product_or_operators(
+        &mut self,
+        node: Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcProductOrOperator> {
+        <Vec<CalcProductOrOperator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
-             [`CalcSum::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CalcSum::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_calc_sum(&mut self, node: &CalcSum) {
-        <CalcSum as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
+        <CalcSum as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
-             [`CalcValue::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CalcValue::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_calc_value(&mut self, node: &CalcValue) {
-        <CalcValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
+        <CalcValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
-             [`CalcValueOrOperator::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CalcValueOrOperator::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
-        <CalcValueOrOperator as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_value_or_operator(
+        &mut self,
+        node: CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcValueOrOperator {
+        <CalcValueOrOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
-             [`Vec < CalcValueOrOperator >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Vec < CalcValueOrOperator >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
-        <[CalcValueOrOperator] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_calc_value_or_operators(
+        &mut self,
+        node: Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcValueOrOperator> {
+        <Vec<CalcValueOrOperator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
-             [`ClassSelector::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ClassSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_class_selector(&mut self, node: &ClassSelector) {
-        <ClassSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class_selector(
+        &mut self,
+        node: ClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassSelector {
+        <ClassSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
-             [`CmykComponent::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CmykComponent::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_cmyk_component(&mut self, node: &CmykComponent) {
-        <CmykComponent as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_cmyk_component(
+        &mut self,
+        node: CmykComponent,
+        __ast_path: &mut AstKindPath,
+    ) -> CmykComponent {
+        <CmykComponent as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
-             [`Color::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Color::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_color(&mut self, node: &Color) {
-        <Color as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
+        <Color as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
-             [`ColorProfileName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ColorProfileName::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
-        <ColorProfileName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_color_profile_name(
+        &mut self,
+        node: ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) -> ColorProfileName {
+        <ColorProfileName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
-             [`Combinator::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Combinator::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_combinator(&mut self, node: &Combinator) {
-        <Combinator as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
+        <Combinator as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
-             [`CombinatorValue::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CombinatorValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_combinator_value(&mut self, node: &CombinatorValue) {
-        <CombinatorValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_combinator_value(
+        &mut self,
+        node: CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> CombinatorValue {
+        <CombinatorValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
-             [`ComplexSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ComplexSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_complex_selector(&mut self, node: &ComplexSelector) {
-        <ComplexSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_complex_selector(
+        &mut self,
+        node: ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelector {
+        <ComplexSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
-             [`ComplexSelectorChildren::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ComplexSelectorChildren::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
-        <ComplexSelectorChildren as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_complex_selector_children(
+        &mut self,
+        node: ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelectorChildren {
+        <ComplexSelectorChildren as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
-             calls [`Vec < ComplexSelectorChildren >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Vec < ComplexSelectorChildren >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
-        <[ComplexSelectorChildren] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_complex_selector_childrens(
+        &mut self,
+        node: Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelectorChildren> {
+        <Vec<ComplexSelectorChildren> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
-             [`Vec < ComplexSelector >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < ComplexSelector >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
-        <[ComplexSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_complex_selectors(
+        &mut self,
+        node: Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelector> {
+        <Vec<ComplexSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
-             [`ComponentValue::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ComponentValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_component_value(&mut self, node: &ComponentValue) {
-        <ComponentValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_component_value(
+        &mut self,
+        node: ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) -> ComponentValue {
+        <ComponentValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
-             < ComponentValue >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < ComponentValue >::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_component_values(&mut self, node: &[ComponentValue]) {
-        <[ComponentValue] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_component_values(
+        &mut self,
+        node: Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComponentValue> {
+        <Vec<ComponentValue> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
-             [`CompoundSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CompoundSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_compound_selector(&mut self, node: &CompoundSelector) {
-        <CompoundSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_compound_selector(
+        &mut self,
+        node: CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelector {
+        <CompoundSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
-             [`CompoundSelectorList::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CompoundSelectorList::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
-        <CompoundSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_compound_selector_list(
+        &mut self,
+        node: CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelectorList {
+        <CompoundSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
-             [`Vec < CompoundSelector >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < CompoundSelector >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
-        <[CompoundSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_compound_selectors(
+        &mut self,
+        node: Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CompoundSelector> {
+        <Vec<CompoundSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
-             [`ContainerCondition::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ContainerCondition::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_container_condition(&mut self, node: &ContainerCondition) {
-        <ContainerCondition as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_condition(
+        &mut self,
+        node: ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerCondition {
+        <ContainerCondition as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
-             [`ContainerName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ContainerName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_container_name(&mut self, node: &ContainerName) {
-        <ContainerName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_name(
+        &mut self,
+        node: ContainerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerName {
+        <ContainerName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
-             [`ContainerQuery::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ContainerQuery::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_container_query(&mut self, node: &ContainerQuery) {
-        <ContainerQuery as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_query(
+        &mut self,
+        node: ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQuery {
+        <ContainerQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
-             [`ContainerQueryAnd::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ContainerQueryAnd::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
-        <ContainerQueryAnd as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_query_and(
+        &mut self,
+        node: ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryAnd {
+        <ContainerQueryAnd as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
-             [`ContainerQueryNot::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ContainerQueryNot::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
-        <ContainerQueryNot as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_query_not(
+        &mut self,
+        node: ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryNot {
+        <ContainerQueryNot as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
-             [`ContainerQueryOr::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ContainerQueryOr::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
-        <ContainerQueryOr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_query_or(
+        &mut self,
+        node: ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryOr {
+        <ContainerQueryOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
-             [`ContainerQueryType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ContainerQueryType::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
-        <ContainerQueryType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_query_type(
+        &mut self,
+        node: ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryType {
+        <ContainerQueryType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
-             [`Vec < ContainerQueryType >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Vec < ContainerQueryType >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
-        <[ContainerQueryType] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_container_query_types(
+        &mut self,
+        node: Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ContainerQueryType> {
+        <Vec<ContainerQueryType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
-             [`CustomHighlightName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CustomHighlightName::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
-        <CustomHighlightName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_custom_highlight_name(
+        &mut self,
+        node: CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomHighlightName {
+        <CustomHighlightName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
-             [`CustomIdent::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CustomIdent::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_custom_ident(&mut self, node: &CustomIdent) {
-        <CustomIdent as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_custom_ident(
+        &mut self,
+        node: CustomIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomIdent {
+        <CustomIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
-             CustomIdent >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             CustomIdent >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
-        <[CustomIdent] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_custom_idents(
+        &mut self,
+        node: Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CustomIdent> {
+        <Vec<CustomIdent> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
-             [`CustomMediaQuery::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CustomMediaQuery::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
-        <CustomMediaQuery as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_custom_media_query(
+        &mut self,
+        node: CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQuery {
+        <CustomMediaQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
-             [`CustomMediaQueryMediaType::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CustomMediaQueryMediaType::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_custom_media_query_media_type(&mut self, node: &CustomMediaQueryMediaType) {
-        <CustomMediaQueryMediaType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_custom_media_query_media_type(
+        &mut self,
+        node: CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQueryMediaType {
+        <CustomMediaQueryMediaType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
-             [`CustomPropertyName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`CustomPropertyName::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
-        <CustomPropertyName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_custom_property_name(
+        &mut self,
+        node: CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomPropertyName {
+        <CustomPropertyName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
-             [`DashedIdent::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`DashedIdent::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_dashed_ident(&mut self, node: &DashedIdent) {
-        <DashedIdent as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_dashed_ident(
+        &mut self,
+        node: DashedIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> DashedIdent {
+        <DashedIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
-             [`Declaration::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Declaration::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_declaration(&mut self, node: &Declaration) {
-        <Declaration as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
+        <Declaration as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
-             [`DeclarationName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`DeclarationName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_declaration_name(&mut self, node: &DeclarationName) {
-        <DeclarationName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_declaration_name(
+        &mut self,
+        node: DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationName {
+        <DeclarationName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
-             [`DeclarationOrAtRule::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`DeclarationOrAtRule::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
-        <DeclarationOrAtRule as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_declaration_or_at_rule(
+        &mut self,
+        node: DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationOrAtRule {
+        <DeclarationOrAtRule as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
-             [`Delimiter::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Delimiter::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_delimiter(&mut self, node: &Delimiter) {
-        <Delimiter as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
+        <Delimiter as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
-             [`DelimiterValue::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`DelimiterValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
-        <DelimiterValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_delimiter_value(
+        &mut self,
+        node: DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) -> DelimiterValue {
+        <DelimiterValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
-             [`Dimension::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Dimension::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_dimension(&mut self, node: &Dimension) {
-        <Dimension as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
+        <Dimension as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
-             [`DimensionToken::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`DimensionToken::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_dimension_token(&mut self, node: &DimensionToken) {
-        <DimensionToken as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_dimension_token(
+        &mut self,
+        node: DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) -> DimensionToken {
+        <DimensionToken as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
-             [`DocumentPrelude::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`DocumentPrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
-        <DocumentPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_document_prelude(
+        &mut self,
+        node: DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPrelude {
+        <DocumentPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
-             calls [`DocumentPreludeMatchingFunction::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`DocumentPreludeMatchingFunction::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_document_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
-        <DocumentPreludeMatchingFunction as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_document_prelude_matching_function(
+        &mut self,
+        node: DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPreludeMatchingFunction {
+        <DocumentPreludeMatchingFunction as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
-             method calls [`Vec < DocumentPreludeMatchingFunction >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Vec < DocumentPreludeMatchingFunction \
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_document_prelude_matching_functions(
+    fn fold_document_prelude_matching_functions(
         &mut self,
-        node: &[DocumentPreludeMatchingFunction],
-    ) {
-        <[DocumentPreludeMatchingFunction] as VisitAllWith<Self>>::visit_children_with(node, self)
+        node: Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<DocumentPreludeMatchingFunction> {
+        <Vec<DocumentPreludeMatchingFunction> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
-             [`ExtensionName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ExtensionName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_extension_name(&mut self, node: &ExtensionName) {
-        <ExtensionName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_extension_name(
+        &mut self,
+        node: ExtensionName,
+        __ast_path: &mut AstKindPath,
+    ) -> ExtensionName {
+        <ExtensionName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
-             [`FamilyName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`FamilyName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_family_name(&mut self, node: &FamilyName) {
-        <FamilyName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
+        <FamilyName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
-             FamilyName >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             FamilyName >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_family_names(&mut self, node: &[FamilyName]) {
-        <[FamilyName] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_family_names(
+        &mut self,
+        node: Vec<FamilyName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<FamilyName> {
+        <Vec<FamilyName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
-             [`Flex::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Flex::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_flex(&mut self, node: &Flex) {
-        <Flex as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
+        <Flex as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
-             [`FontFeatureValuesPrelude::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`FontFeatureValuesPrelude::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
-        <FontFeatureValuesPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_font_feature_values_prelude(
+        &mut self,
+        node: FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> FontFeatureValuesPrelude {
+        <FontFeatureValuesPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
-             [`ForgivingComplexSelector::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ForgivingComplexSelector::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
-        <ForgivingComplexSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_forgiving_complex_selector(
+        &mut self,
+        node: ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingComplexSelector {
+        <ForgivingComplexSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingComplexSelector >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Vec < ForgivingComplexSelector >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
-        <[ForgivingComplexSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_forgiving_complex_selectors(
+        &mut self,
+        node: Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingComplexSelector> {
+        <Vec<ForgivingComplexSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
-             [`ForgivingRelativeSelector::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ForgivingRelativeSelector::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
-        <ForgivingRelativeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_forgiving_relative_selector(
+        &mut self,
+        node: ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelector {
+        <ForgivingRelativeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
-             calls [`ForgivingRelativeSelectorList::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`ForgivingRelativeSelectorList::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
-        <ForgivingRelativeSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_forgiving_relative_selector_list(
+        &mut self,
+        node: ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelectorList {
+        <ForgivingRelativeSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
-             calls [`Vec < ForgivingRelativeSelector >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Vec < ForgivingRelativeSelector >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
-        <[ForgivingRelativeSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_forgiving_relative_selectors(
+        &mut self,
+        node: Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingRelativeSelector> {
+        <Vec<ForgivingRelativeSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
-             [`ForgivingSelectorList::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ForgivingSelectorList::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
-        <ForgivingSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_forgiving_selector_list(
+        &mut self,
+        node: ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingSelectorList {
+        <ForgivingSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
-             [`Frequency::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Frequency::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_frequency(&mut self, node: &Frequency) {
-        <Frequency as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
+        <Frequency as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
-             [`FrequencyPercentage::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`FrequencyPercentage::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
-        <FrequencyPercentage as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_frequency_percentage(
+        &mut self,
+        node: FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> FrequencyPercentage {
+        <FrequencyPercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Function::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <Function as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+        <Function as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
-             [`FunctionName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`FunctionName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_function_name(&mut self, node: &FunctionName) {
-        <FunctionName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_function_name(
+        &mut self,
+        node: FunctionName,
+        __ast_path: &mut AstKindPath,
+    ) -> FunctionName {
+        <FunctionName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
-             [`GeneralEnclosed::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`GeneralEnclosed::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
-        <GeneralEnclosed as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_general_enclosed(
+        &mut self,
+        node: GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) -> GeneralEnclosed {
+        <GeneralEnclosed as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
-             [`HexColor::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`HexColor::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_hex_color(&mut self, node: &HexColor) {
-        <HexColor as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
+        <HexColor as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
-             [`Hue::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Hue::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_hue(&mut self, node: &Hue) {
-        <Hue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
+        <Hue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
-             [`IdSelector::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`IdSelector::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_id_selector(&mut self, node: &IdSelector) {
-        <IdSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
+        <IdSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Ident::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <Ident as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+        <Ident as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_idents(&mut self, node: &[Ident]) {
-        <[Ident] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
+        <Vec<Ident> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
-             [`ImportConditions::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportConditions::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_import_conditions(&mut self, node: &ImportConditions) {
-        <ImportConditions as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_conditions(
+        &mut self,
+        node: ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportConditions {
+        <ImportConditions as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
-             [`ImportHref::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportHref::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_import_href(&mut self, node: &ImportHref) {
-        <ImportHref as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
+        <ImportHref as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
-             [`ImportLayerName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportLayerName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
-        <ImportLayerName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_layer_name(
+        &mut self,
+        node: ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportLayerName {
+        <ImportLayerName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
-             [`ImportPrelude::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportPrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_import_prelude(&mut self, node: &ImportPrelude) {
-        <ImportPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_prelude(
+        &mut self,
+        node: ImportPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPrelude {
+        <ImportPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
-             [`ImportantFlag::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportantFlag::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_important_flag(&mut self, node: &ImportantFlag) {
-        <ImportantFlag as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_important_flag(
+        &mut self,
+        node: ImportantFlag,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportantFlag {
+        <ImportantFlag as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
-             [`Integer::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Integer::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_integer(&mut self, node: &Integer) {
-        <Integer as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
+        <Integer as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
-             [`KeyframeBlock::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`KeyframeBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
-        <KeyframeBlock as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_keyframe_block(
+        &mut self,
+        node: KeyframeBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeBlock {
+        <KeyframeBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
-             [`KeyframeSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`KeyframeSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
-        <KeyframeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_keyframe_selector(
+        &mut self,
+        node: KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeSelector {
+        <KeyframeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
-             [`Vec < KeyframeSelector >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < KeyframeSelector >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
-        <[KeyframeSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_keyframe_selectors(
+        &mut self,
+        node: Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<KeyframeSelector> {
+        <Vec<KeyframeSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
-             [`KeyframesName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`KeyframesName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_keyframes_name(&mut self, node: &KeyframesName) {
-        <KeyframesName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_keyframes_name(
+        &mut self,
+        node: KeyframesName,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesName {
+        <KeyframesName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
-             [`KeyframesPseudoFunction::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`KeyframesPseudoFunction::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
-        <KeyframesPseudoFunction as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_keyframes_pseudo_function(
+        &mut self,
+        node: KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoFunction {
+        <KeyframesPseudoFunction as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
-             [`KeyframesPseudoPrefix::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`KeyframesPseudoPrefix::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
-        <KeyframesPseudoPrefix as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_keyframes_pseudo_prefix(
+        &mut self,
+        node: KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoPrefix {
+        <KeyframesPseudoPrefix as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
-             [`LayerName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`LayerName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_layer_name(&mut self, node: &LayerName) {
-        <LayerName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
+        <LayerName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
-             [`LayerNameList::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`LayerNameList::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_layer_name_list(&mut self, node: &LayerNameList) {
-        <LayerNameList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_layer_name_list(
+        &mut self,
+        node: LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerNameList {
+        <LayerNameList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
-             LayerName >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             LayerName >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_layer_names(&mut self, node: &[LayerName]) {
-        <[LayerName] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_layer_names(
+        &mut self,
+        node: Vec<LayerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<LayerName> {
+        <Vec<LayerName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
-             [`LayerPrelude::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`LayerPrelude::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
-        <LayerPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_layer_prelude(
+        &mut self,
+        node: LayerPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerPrelude {
+        <LayerPrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
-             [`Length::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Length::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_length(&mut self, node: &Length) {
-        <Length as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
+        <Length as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
-             [`LengthPercentage::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`LengthPercentage::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_length_percentage(&mut self, node: &LengthPercentage) {
-        <LengthPercentage as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_length_percentage(
+        &mut self,
+        node: LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> LengthPercentage {
+        <LengthPercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
-             [`ListOfComponentValues::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ListOfComponentValues::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
-        <ListOfComponentValues as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_list_of_component_values(
+        &mut self,
+        node: ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) -> ListOfComponentValues {
+        <ListOfComponentValues as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
-             [`MediaAnd::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaAnd::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_media_and(&mut self, node: &MediaAnd) {
-        <MediaAnd as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
+        <MediaAnd as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
-             [`MediaCondition::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaCondition::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_media_condition(&mut self, node: &MediaCondition) {
-        <MediaCondition as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_condition(
+        &mut self,
+        node: MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaCondition {
+        <MediaCondition as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
-             [`MediaConditionAllType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaConditionAllType::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
-        <MediaConditionAllType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_condition_all_type(
+        &mut self,
+        node: MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionAllType {
+        <MediaConditionAllType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
-             calls [`Vec < MediaConditionAllType >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Vec < MediaConditionAllType >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
-        <[MediaConditionAllType] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_condition_all_types(
+        &mut self,
+        node: Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionAllType> {
+        <Vec<MediaConditionAllType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
-             [`MediaConditionType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaConditionType::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
-        <MediaConditionType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_condition_type(
+        &mut self,
+        node: MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionType {
+        <MediaConditionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOr::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaConditionWithoutOr::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
-        <MediaConditionWithoutOr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_condition_without_or(
+        &mut self,
+        node: MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOr {
+        <MediaConditionWithoutOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
-             [`MediaConditionWithoutOrType::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`MediaConditionWithoutOrType::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_media_condition_without_or_type(&mut self, node: &MediaConditionWithoutOrType) {
-        <MediaConditionWithoutOrType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_condition_without_or_type(
+        &mut self,
+        node: MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOrType {
+        <MediaConditionWithoutOrType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
-             method calls [`Vec < MediaConditionWithoutOrType >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Vec < MediaConditionWithoutOrType >::fold_children_with_ast_path`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_media_condition_without_or_types(&mut self, node: &[MediaConditionWithoutOrType]) {
-        <[MediaConditionWithoutOrType] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_condition_without_or_types(
+        &mut self,
+        node: Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionWithoutOrType> {
+        <Vec<MediaConditionWithoutOrType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
-             [`MediaFeature::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaFeature::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_media_feature(&mut self, node: &MediaFeature) {
-        <MediaFeature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature(
+        &mut self,
+        node: MediaFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeature {
+        <MediaFeature as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
-             [`MediaFeatureBoolean::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaFeatureBoolean::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
-        <MediaFeatureBoolean as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature_boolean(
+        &mut self,
+        node: MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureBoolean {
+        <MediaFeatureBoolean as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
-             [`MediaFeatureName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaFeatureName::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
-        <MediaFeatureName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature_name(
+        &mut self,
+        node: MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureName {
+        <MediaFeatureName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
-             [`MediaFeaturePlain::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaFeaturePlain::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
-        <MediaFeaturePlain as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature_plain(
+        &mut self,
+        node: MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeaturePlain {
+        <MediaFeaturePlain as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
-             [`MediaFeatureRange::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaFeatureRange::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
-        <MediaFeatureRange as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature_range(
+        &mut self,
+        node: MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRange {
+        <MediaFeatureRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeComparison::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`MediaFeatureRangeComparison::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
-        <MediaFeatureRangeComparison as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature_range_comparison(
+        &mut self,
+        node: MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeComparison {
+        <MediaFeatureRangeComparison as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`MediaFeatureRangeInterval::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaFeatureRangeInterval::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
-        <MediaFeatureRangeInterval as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature_range_interval(
+        &mut self,
+        node: MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeInterval {
+        <MediaFeatureRangeInterval as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
-             [`MediaFeatureValue::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaFeatureValue::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
-        <MediaFeatureValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_feature_value(
+        &mut self,
+        node: MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureValue {
+        <MediaFeatureValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
-             [`MediaInParens::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaInParens::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_media_in_parens(&mut self, node: &MediaInParens) {
-        <MediaInParens as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_in_parens(
+        &mut self,
+        node: MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaInParens {
+        <MediaInParens as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
-             [`MediaNot::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaNot::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_media_not(&mut self, node: &MediaNot) {
-        <MediaNot as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
+        <MediaNot as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
-             [`MediaOr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaOr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_media_or(&mut self, node: &MediaOr) {
-        <MediaOr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
+        <MediaOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
-             [`MediaQuery::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaQuery::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_media_query(&mut self, node: &MediaQuery) {
-        <MediaQuery as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
+        <MediaQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
-             [`MediaQueryList::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaQueryList::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_media_query_list(&mut self, node: &MediaQueryList) {
-        <MediaQueryList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_query_list(
+        &mut self,
+        node: MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaQueryList {
+        <MediaQueryList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
-             MediaQuery >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             MediaQuery >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_media_querys(&mut self, node: &[MediaQuery]) {
-        <[MediaQuery] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_querys(
+        &mut self,
+        node: Vec<MediaQuery>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaQuery> {
+        <Vec<MediaQuery> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
-             [`MediaType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MediaType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_media_type(&mut self, node: &MediaType) {
-        <MediaType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
+        <MediaType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
-             [`NamedNamespace::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`NamedNamespace::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_named_namespace(&mut self, node: &NamedNamespace) {
-        <NamedNamespace as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_named_namespace(
+        &mut self,
+        node: NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedNamespace {
+        <NamedNamespace as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Namespace::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <Namespace as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
+        <Namespace as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
-             [`NamespacePrefix::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`NamespacePrefix::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
-        <NamespacePrefix as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_namespace_prefix(
+        &mut self,
+        node: NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrefix {
+        <NamespacePrefix as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
-             [`NamespacePrelude::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`NamespacePrelude::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
-        <NamespacePrelude as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_namespace_prelude(
+        &mut self,
+        node: NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrelude {
+        <NamespacePrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
-             [`NamespacePreludeUri::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`NamespacePreludeUri::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
-        <NamespacePreludeUri as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_namespace_prelude_uri(
+        &mut self,
+        node: NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePreludeUri {
+        <NamespacePreludeUri as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
-             [`NestingSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`NestingSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_nesting_selector(&mut self, node: &NestingSelector) {
-        <NestingSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_nesting_selector(
+        &mut self,
+        node: NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> NestingSelector {
+        <NestingSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Number::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <Number as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+        <Number as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
-             [`NumberType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`NumberType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_number_type(&mut self, node: &NumberType) {
-        <NumberType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
+        <NumberType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
-             calls [`Option < Box < AtRulePrelude > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < Box < AtRulePrelude > >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>) {
-        <Option<Box<AtRulePrelude>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_at_rule_prelude(
+        &mut self,
+        node: Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<AtRulePrelude>> {
+        <Option<Box<AtRulePrelude>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < swc_atoms :: Atom >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <Option<swc_atoms::Atom> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
+        <Option<swc_atoms::Atom> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorMatcher >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Option < AttributeSelectorMatcher >::fold_children_with_ast_path`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_attribute_selector_matcher(&mut self, node: &Option<AttributeSelectorMatcher>) {
-        <Option<AttributeSelectorMatcher> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_attribute_selector_matcher(
+        &mut self,
+        node: Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorMatcher> {
+        <Option<AttributeSelectorMatcher> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
-             method calls [`Option < AttributeSelectorModifier >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Option < AttributeSelectorModifier >::fold_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_attribute_selector_modifier(&mut self, node: &Option<AttributeSelectorModifier>) {
-        <Option<AttributeSelectorModifier> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_attribute_selector_modifier(
+        &mut self,
+        node: Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorModifier> {
+        <Option<AttributeSelectorModifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
-             calls [`Option < AttributeSelectorValue >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < AttributeSelectorValue >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_attribute_selector_value(&mut self, node: &Option<AttributeSelectorValue>) {
-        <Option<AttributeSelectorValue> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_attribute_selector_value(
+        &mut self,
+        node: Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorValue> {
+        <Option<AttributeSelectorValue> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
-             [`Option < Combinator >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < Combinator >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
-        <Option<Combinator> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_combinator(
+        &mut self,
+        node: Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Combinator> {
+        <Option<Combinator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
-             [`Option < ContainerName >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < ContainerName >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_container_name(&mut self, node: &Option<ContainerName>) {
-        <Option<ContainerName> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_container_name(
+        &mut self,
+        node: Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ContainerName> {
+        <Option<ContainerName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
-             calls [`Option < ForgivingSelectorList >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < ForgivingSelectorList >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_forgiving_selector_list(&mut self, node: &Option<ForgivingSelectorList>) {
-        <Option<ForgivingSelectorList> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_forgiving_selector_list(
+        &mut self,
+        node: Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ForgivingSelectorList> {
+        <Option<ForgivingSelectorList> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
-             [`Option < Box < Function > >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < Box < Function > >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_function(&mut self, node: &Option<Box<Function>>) {
-        <Option<Box<Function>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_function(
+        &mut self,
+        node: Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Function>> {
+        <Option<Box<Function>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             Ident >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <Option<Ident> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
+        <Option<Ident> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
-             method calls [`Option < Box < ImportConditions > >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Option < Box < ImportConditions > >::fold_children_with_ast_path`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>) {
-        <Option<Box<ImportConditions>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_import_conditions(
+        &mut self,
+        node: Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportConditions>> {
+        <Option<Box<ImportConditions>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
-             calls [`Option < Box < ImportLayerName > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < Box < ImportLayerName > >::fold_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>) {
-        <Option<Box<ImportLayerName>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_import_layer_name(
+        &mut self,
+        node: Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportLayerName>> {
+        <Option<Box<ImportLayerName>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
-             [`Option < ImportantFlag >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < ImportantFlag >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>) {
-        <Option<ImportantFlag> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_important_flag(
+        &mut self,
+        node: Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ImportantFlag> {
+        <Option<ImportantFlag> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
-             method calls [`Option < Box < MediaConditionType > >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Option < Box < MediaConditionType > >::fold_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_media_condition_type(&mut self, node: &Option<Box<MediaConditionType>>) {
-        <Option<Box<MediaConditionType>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_media_condition_type(
+        &mut self,
+        node: Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaConditionType>> {
+        <Option<Box<MediaConditionType>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
-             calls [`Option < Box < MediaQueryList > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < Box < MediaQueryList > >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>) {
-        <Option<Box<MediaQueryList>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_media_query_list(
+        &mut self,
+        node: Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaQueryList>> {
+        <Option<Box<MediaQueryList>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
-             [`Option < MediaType >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < MediaType >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_media_type(&mut self, node: &Option<MediaType>) {
-        <Option<MediaType> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_media_type(
+        &mut self,
+        node: Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<MediaType> {
+        <Option<MediaType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < Namespace >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <Option<Namespace> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_namespace(
+        &mut self,
+        node: Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Namespace> {
+        <Option<Namespace> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
-             [`Option < NamespacePrefix >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < NamespacePrefix >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_namespace_prefix(&mut self, node: &Option<NamespacePrefix>) {
-        <Option<NamespacePrefix> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_namespace_prefix(
+        &mut self,
+        node: Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NamespacePrefix> {
+        <Option<NamespacePrefix> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
-             [`Option < NestingSelector >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < NestingSelector >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_nesting_selector(&mut self, node: &Option<NestingSelector>) {
-        <Option<NestingSelector> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_nesting_selector(
+        &mut self,
+        node: Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NestingSelector> {
+        <Option<NestingSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
-             Number >::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             Number >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_number(&mut self, node: &Option<Number>) {
-        <Option<Number> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_number(
+        &mut self,
+        node: Option<Number>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Number> {
+        <Option<Number> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
-             method calls [`Option < Vec < PageSelectorPseudo > >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Option < Vec < PageSelectorPseudo > >::fold_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_page_selector_pseudos(&mut self, node: &Option<Vec<PageSelectorPseudo>>) {
-        <Option<Vec<PageSelectorPseudo>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_page_selector_pseudos(
+        &mut self,
+        node: Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PageSelectorPseudo>> {
+        <Option<Vec<PageSelectorPseudo>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
-             [`Option < PageSelectorType >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < PageSelectorType >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_page_selector_type(&mut self, node: &Option<PageSelectorType>) {
-        <Option<PageSelectorType> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_page_selector_type(
+        &mut self,
+        node: Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<PageSelectorType> {
+        <Option<PageSelectorType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
              this method calls [`Option < Vec < PseudoClassSelectorChildren > \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_pseudo_class_selector_childrens(
+    fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
-        node: &Option<Vec<PseudoClassSelectorChildren>>,
-    ) {
-        <Option<Vec<PseudoClassSelectorChildren>> as VisitAllWith<Self>>::visit_children_with(
-            node, self,
-        )
+        node: Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoClassSelectorChildren>> {
+        < Option < Vec < PseudoClassSelectorChildren > > as FoldWithAstPath < Self > > :: fold_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
              default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_pseudo_element_selector_childrens(
+    fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
-        node: &Option<Vec<PseudoElementSelectorChildren>>,
-    ) {
-        <Option<Vec<PseudoElementSelectorChildren>> as VisitAllWith<Self>>::visit_children_with(
-            node, self,
-        )
+        node: Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoElementSelectorChildren>> {
+        < Option < Vec < PseudoElementSelectorChildren > > as FoldWithAstPath < Self > > :: fold_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
-             [`Option < SimpleBlock >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < SimpleBlock >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>) {
-        <Option<SimpleBlock> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_simple_block(
+        &mut self,
+        node: Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<SimpleBlock> {
+        <Option<SimpleBlock> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
-             calls [`Option < Box < TypeSelector > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < Box < TypeSelector > >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>) {
-        <Option<Box<TypeSelector>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_type_selector(
+        &mut self,
+        node: Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TypeSelector>> {
+        <Option<Box<TypeSelector>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
-             calls [`Option < Vec < UrlModifier > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < Vec < UrlModifier > >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>) {
-        <Option<Vec<UrlModifier>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_url_modifiers(
+        &mut self,
+        node: Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<UrlModifier>> {
+        <Option<Vec<UrlModifier>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
-             [`Option < Box < UrlValue > >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < Box < UrlValue > >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_url_value(&mut self, node: &Option<Box<UrlValue>>) {
-        <Option<Box<UrlValue>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_url_value(
+        &mut self,
+        node: Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<UrlValue>> {
+        <Option<Box<UrlValue>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
-             [`PageSelector::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`PageSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_page_selector(&mut self, node: &PageSelector) {
-        <PageSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_page_selector(
+        &mut self,
+        node: PageSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelector {
+        <PageSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
-             [`PageSelectorList::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`PageSelectorList::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
-        <PageSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_page_selector_list(
+        &mut self,
+        node: PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorList {
+        <PageSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
-             [`PageSelectorPseudo::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`PageSelectorPseudo::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
-        <PageSelectorPseudo as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_page_selector_pseudo(
+        &mut self,
+        node: PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorPseudo {
+        <PageSelectorPseudo as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
-             [`Vec < PageSelectorPseudo >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Vec < PageSelectorPseudo >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
-        <[PageSelectorPseudo] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_page_selector_pseudos(
+        &mut self,
+        node: Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelectorPseudo> {
+        <Vec<PageSelectorPseudo> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
-             [`PageSelectorType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`PageSelectorType::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
-        <PageSelectorType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_page_selector_type(
+        &mut self,
+        node: PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorType {
+        <PageSelectorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
-             PageSelector >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             PageSelector >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_page_selectors(&mut self, node: &[PageSelector]) {
-        <[PageSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_page_selectors(
+        &mut self,
+        node: Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelector> {
+        <Vec<PageSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
-             [`Percentage::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Percentage::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_percentage(&mut self, node: &Percentage) {
-        <Percentage as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
+        <Percentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
-             [`PseudoClassSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`PseudoClassSelector::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
-        <PseudoClassSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pseudo_class_selector(
+        &mut self,
+        node: PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelector {
+        <PseudoClassSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
-             [`PseudoClassSelectorChildren::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`PseudoClassSelectorChildren::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
-        <PseudoClassSelectorChildren as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pseudo_class_selector_children(
+        &mut self,
+        node: PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelectorChildren {
+        <PseudoClassSelectorChildren as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoClassSelectorChildren >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Vec < PseudoClassSelectorChildren >::fold_children_with_ast_path`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
-        <[PseudoClassSelectorChildren] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pseudo_class_selector_childrens(
+        &mut self,
+        node: Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoClassSelectorChildren> {
+        <Vec<PseudoClassSelectorChildren> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
-             [`PseudoElementSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`PseudoElementSelector::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
-        <PseudoElementSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pseudo_element_selector(
+        &mut self,
+        node: PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelector {
+        <PseudoElementSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
-             calls [`PseudoElementSelectorChildren::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`PseudoElementSelectorChildren::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
-        <PseudoElementSelectorChildren as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pseudo_element_selector_children(
+        &mut self,
+        node: PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelectorChildren {
+        <PseudoElementSelectorChildren as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
-             method calls [`Vec < PseudoElementSelectorChildren >::visit_children_with`]. This \
-             method unconditionally calls the visitor method for all children because it's defined \
-             in the trait [VisitAll]."]
+             method calls [`Vec < PseudoElementSelectorChildren >::fold_children_with_ast_path`]. \
+             If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
-        <[PseudoElementSelectorChildren] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pseudo_element_selector_childrens(
+        &mut self,
+        node: Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoElementSelectorChildren> {
+        <Vec<PseudoElementSelectorChildren> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
-             [`QualifiedRule::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`QualifiedRule::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
-        <QualifiedRule as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_qualified_rule(
+        &mut self,
+        node: QualifiedRule,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRule {
+        <QualifiedRule as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
-             [`QualifiedRulePrelude::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`QualifiedRulePrelude::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
-        <QualifiedRulePrelude as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_qualified_rule_prelude(
+        &mut self,
+        node: QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRulePrelude {
+        <QualifiedRulePrelude as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
-             [`QueryInParens::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`QueryInParens::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_query_in_parens(&mut self, node: &QueryInParens) {
-        <QueryInParens as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_query_in_parens(
+        &mut self,
+        node: QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> QueryInParens {
+        <QueryInParens as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
-             [`Ratio::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Ratio::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_ratio(&mut self, node: &Ratio) {
-        <Ratio as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
+        <Ratio as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
-             [`RelativeSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`RelativeSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_relative_selector(&mut self, node: &RelativeSelector) {
-        <RelativeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_relative_selector(
+        &mut self,
+        node: RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelector {
+        <RelativeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
-             [`RelativeSelectorList::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`RelativeSelectorList::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
-        <RelativeSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_relative_selector_list(
+        &mut self,
+        node: RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelectorList {
+        <RelativeSelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
-             [`Vec < RelativeSelector >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < RelativeSelector >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
-        <[RelativeSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_relative_selectors(
+        &mut self,
+        node: Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<RelativeSelector> {
+        <Vec<RelativeSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
-             [`Resolution::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Resolution::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_resolution(&mut self, node: &Resolution) {
-        <Resolution as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
+        <Resolution as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
-             [`Rule::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Rule::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_rule(&mut self, node: &Rule) {
-        <Rule as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
+        <Rule as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_rules(&mut self, node: &[Rule]) {
-        <[Rule] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
+        <Vec<Rule> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
-             [`ScopeRange::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ScopeRange::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_scope_range(&mut self, node: &ScopeRange) {
-        <ScopeRange as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
+        <ScopeRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
-             [`SelectorList::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SelectorList::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_selector_list(&mut self, node: &SelectorList) {
-        <SelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_selector_list(
+        &mut self,
+        node: SelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> SelectorList {
+        <SelectorList as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
-             [`SequenceOfCustomIdents::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SequenceOfCustomIdents::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
-        <SequenceOfCustomIdents as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_sequence_of_custom_idents(
+        &mut self,
+        node: SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) -> SequenceOfCustomIdents {
+        <SequenceOfCustomIdents as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
-             [`SimpleBlock::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SimpleBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_simple_block(&mut self, node: &SimpleBlock) {
-        <SimpleBlock as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_simple_block(
+        &mut self,
+        node: SimpleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleBlock {
+        <SimpleBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
-             [`SizeFeature::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SizeFeature::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_size_feature(&mut self, node: &SizeFeature) {
-        <SizeFeature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature(
+        &mut self,
+        node: SizeFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeature {
+        <SizeFeature as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
-             [`SizeFeatureBoolean::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SizeFeatureBoolean::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
-        <SizeFeatureBoolean as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature_boolean(
+        &mut self,
+        node: SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureBoolean {
+        <SizeFeatureBoolean as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
-             [`SizeFeatureName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SizeFeatureName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
-        <SizeFeatureName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature_name(
+        &mut self,
+        node: SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureName {
+        <SizeFeatureName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
-             [`SizeFeaturePlain::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SizeFeaturePlain::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
-        <SizeFeaturePlain as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature_plain(
+        &mut self,
+        node: SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeaturePlain {
+        <SizeFeaturePlain as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
-             [`SizeFeatureRange::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SizeFeatureRange::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
-        <SizeFeatureRange as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature_range(
+        &mut self,
+        node: SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRange {
+        <SizeFeatureRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeComparison::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`SizeFeatureRangeComparison::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
-        <SizeFeatureRangeComparison as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature_range_comparison(
+        &mut self,
+        node: SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeComparison {
+        <SizeFeatureRangeComparison as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
-             [`SizeFeatureRangeInterval::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SizeFeatureRangeInterval::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
-        <SizeFeatureRangeInterval as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature_range_interval(
+        &mut self,
+        node: SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeInterval {
+        <SizeFeatureRangeInterval as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
-             [`SizeFeatureValue::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SizeFeatureValue::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
-        <SizeFeatureValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_size_feature_value(
+        &mut self,
+        node: SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureValue {
+        <SizeFeatureValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`swc_common :: Span::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <swc_common::Span as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
+        <swc_common::Span as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Str::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <Str as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+        <Str as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
-             [`StyleBlock::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`StyleBlock::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_style_block(&mut self, node: &StyleBlock) {
-        <StyleBlock as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
+        <StyleBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
-             [`Stylesheet::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Stylesheet::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_stylesheet(&mut self, node: &Stylesheet) {
-        <Stylesheet as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
+        <Stylesheet as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
-             [`SubclassSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SubclassSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
-        <SubclassSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_subclass_selector(
+        &mut self,
+        node: SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> SubclassSelector {
+        <SubclassSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
-             [`Vec < SubclassSelector >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < SubclassSelector >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
-        <[SubclassSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_subclass_selectors(
+        &mut self,
+        node: Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SubclassSelector> {
+        <Vec<SubclassSelector> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
-             [`SupportsAnd::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SupportsAnd::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_supports_and(&mut self, node: &SupportsAnd) {
-        <SupportsAnd as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_and(
+        &mut self,
+        node: SupportsAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsAnd {
+        <SupportsAnd as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
-             [`SupportsCondition::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SupportsCondition::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_supports_condition(&mut self, node: &SupportsCondition) {
-        <SupportsCondition as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_condition(
+        &mut self,
+        node: SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsCondition {
+        <SupportsCondition as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
-             [`SupportsConditionType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SupportsConditionType::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
-        <SupportsConditionType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_condition_type(
+        &mut self,
+        node: SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsConditionType {
+        <SupportsConditionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
-             calls [`Vec < SupportsConditionType >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Vec < SupportsConditionType >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
-        <[SupportsConditionType] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_condition_types(
+        &mut self,
+        node: Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SupportsConditionType> {
+        <Vec<SupportsConditionType> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
-             [`SupportsFeature::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SupportsFeature::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_supports_feature(&mut self, node: &SupportsFeature) {
-        <SupportsFeature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_feature(
+        &mut self,
+        node: SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsFeature {
+        <SupportsFeature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
-             [`SupportsInParens::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SupportsInParens::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
-        <SupportsInParens as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_in_parens(
+        &mut self,
+        node: SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsInParens {
+        <SupportsInParens as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
-             [`SupportsNot::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SupportsNot::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_supports_not(&mut self, node: &SupportsNot) {
-        <SupportsNot as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_not(
+        &mut self,
+        node: SupportsNot,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsNot {
+        <SupportsNot as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
-             [`SupportsOr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SupportsOr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_supports_or(&mut self, node: &SupportsOr) {
-        <SupportsOr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
+        <SupportsOr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
-             [`TagNameSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TagNameSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
-        <TagNameSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_tag_name_selector(
+        &mut self,
+        node: TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TagNameSelector {
+        <TagNameSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
-             [`Time::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Time::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_time(&mut self, node: &Time) {
-        <Time as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
+        <Time as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
-             [`TimePercentage::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TimePercentage::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_time_percentage(&mut self, node: &TimePercentage) {
-        <TimePercentage as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_time_percentage(
+        &mut self,
+        node: TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> TimePercentage {
+        <TimePercentage as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Token::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <Token as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
+        <Token as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TokenAndSpan::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <TokenAndSpan as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_token_and_span(
+        &mut self,
+        node: TokenAndSpan,
+        __ast_path: &mut AstKindPath,
+    ) -> TokenAndSpan {
+        <TokenAndSpan as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
-             [`TypeSelector::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TypeSelector::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_type_selector(&mut self, node: &TypeSelector) {
-        <TypeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_type_selector(
+        &mut self,
+        node: TypeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TypeSelector {
+        <TypeSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
-             [`UnicodeRange::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UnicodeRange::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_unicode_range(&mut self, node: &UnicodeRange) {
-        <UnicodeRange as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_unicode_range(
+        &mut self,
+        node: UnicodeRange,
+        __ast_path: &mut AstKindPath,
+    ) -> UnicodeRange {
+        <UnicodeRange as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
-             [`UniversalSelector::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`UniversalSelector::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_universal_selector(&mut self, node: &UniversalSelector) {
-        <UniversalSelector as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_universal_selector(
+        &mut self,
+        node: UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> UniversalSelector {
+        <UniversalSelector as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
-             [`UnknownDimension::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`UnknownDimension::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
-        <UnknownDimension as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_unknown_dimension(
+        &mut self,
+        node: UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) -> UnknownDimension {
+        <UnknownDimension as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
-             [`Url::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Url::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_url(&mut self, node: &Url) {
-        <Url as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
+        <Url as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
-             [`UrlKeyValue::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UrlKeyValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
-        <UrlKeyValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_url_key_value(
+        &mut self,
+        node: UrlKeyValue,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlKeyValue {
+        <UrlKeyValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
-             [`UrlModifier::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UrlModifier::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_url_modifier(&mut self, node: &UrlModifier) {
-        <UrlModifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_url_modifier(
+        &mut self,
+        node: UrlModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlModifier {
+        <UrlModifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
-             UrlModifier >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             UrlModifier >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
-        <[UrlModifier] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_url_modifiers(
+        &mut self,
+        node: Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<UrlModifier> {
+        <Vec<UrlModifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
-             [`UrlValue::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UrlValue::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_url_value(&mut self, node: &UrlValue) {
-        <UrlValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
+        <UrlValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
-             [`UrlValueRaw::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UrlValueRaw::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
-        <UrlValueRaw as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_url_value_raw(
+        &mut self,
+        node: UrlValueRaw,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlValueRaw {
+        <UrlValueRaw as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    }
+    #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
+             [`WqName::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
+    #[inline]
+    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
+        <WqName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    }
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> FoldAstPath for &mut V
+where
+    V: ?Sized + FoldAstPath,
+{
+    #[inline]
+    fn fold_absolute_color_base(
+        &mut self,
+        node: AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) -> AbsoluteColorBase {
+        <V as FoldAstPath>::fold_absolute_color_base(&mut **self, node, __ast_path)
+    }
+
+    #[inline]
+    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
+        <V as FoldAstPath>::fold_alpha_value(&mut **self, node, __ast_path)
+    }
+
+    #[inline]
+    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
+        <V as FoldAstPath>::fold_an_plus_b(&mut **self, node, __ast_path)
+    }
+
+    #[inline]
+    fn fold_an_plus_b_notation(
+        &mut self,
+        node: AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) -> AnPlusBNotation {
+        <V as FoldAstPath>::fold_an_plus_b_notation(&mut **self, node, __ast_path)
+    }
+
+    #[inline]
+    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
+        <V as FoldAstPath>::fold_angle(&mut **self, node, __ast_path)
+    }
+
+    #[inline]
+    fn fold_angle_percentage(
+        &mut self,
+        node: AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> AnglePercentage {
+        <V as FoldAstPath>::fold_angle_percentage(&mut **self, node, __ast_path)
+    }
+
+    #[inline]
+    fn fold_any_namespace(
+        &mut self,
+        node: AnyNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> AnyNamespace {
+        <V as FoldAstPath>::fold_any_namespace(&mut **self, node, __ast_path)
     }
-    #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
-             [`WqName::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+
     #[inline]
-    fn visit_wq_name(&mut self, node: &WqName) {
-        <WqName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
+        <V as FoldAstPath>::fold_at_rule(&mut **self, node, __ast_path)
     }
-}
-impl<V> VisitAll for &mut V
-where
-    V: ?Sized + VisitAll,
-{
+
     #[inline]
-    fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
-        <V as VisitAll>::visit_absolute_color_base(&mut **self, node)
+    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
+        <V as FoldAstPath>::fold_at_rule_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_alpha_value(&mut self, node: &AlphaValue) {
-        <V as VisitAll>::visit_alpha_value(&mut **self, node)
+    fn fold_at_rule_prelude(
+        &mut self,
+        node: AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> AtRulePrelude {
+        <V as FoldAstPath>::fold_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_an_plus_b(&mut self, node: &AnPlusB) {
-        <V as VisitAll>::visit_an_plus_b(&mut **self, node)
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
+        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
-        <V as VisitAll>::visit_an_plus_b_notation(&mut **self, node)
+    fn fold_attribute_selector(
+        &mut self,
+        node: AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelector {
+        <V as FoldAstPath>::fold_attribute_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_angle(&mut self, node: &Angle) {
-        <V as VisitAll>::visit_angle(&mut **self, node)
+    fn fold_attribute_selector_matcher(
+        &mut self,
+        node: AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcher {
+        <V as FoldAstPath>::fold_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
-        <V as VisitAll>::visit_angle_percentage(&mut **self, node)
+    fn fold_attribute_selector_matcher_value(
+        &mut self,
+        node: AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcherValue {
+        <V as FoldAstPath>::fold_attribute_selector_matcher_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_any_namespace(&mut self, node: &AnyNamespace) {
-        <V as VisitAll>::visit_any_namespace(&mut **self, node)
+    fn fold_attribute_selector_modifier(
+        &mut self,
+        node: AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorModifier {
+        <V as FoldAstPath>::fold_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_at_rule(&mut self, node: &AtRule) {
-        <V as VisitAll>::visit_at_rule(&mut **self, node)
+    fn fold_attribute_selector_value(
+        &mut self,
+        node: AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorValue {
+        <V as FoldAstPath>::fold_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_at_rule_name(&mut self, node: &AtRuleName) {
-        <V as VisitAll>::visit_at_rule_name(&mut **self, node)
+    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
+        <V as FoldAstPath>::fold_bin_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
-        <V as VisitAll>::visit_at_rule_prelude(&mut **self, node)
+    fn fold_calc_operator(
+        &mut self,
+        node: CalcOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperator {
+        <V as FoldAstPath>::fold_calc_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
+    fn fold_calc_operator_type(
+        &mut self,
+        node: CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperatorType {
+        <V as FoldAstPath>::fold_calc_operator_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
-        <V as VisitAll>::visit_attribute_selector(&mut **self, node)
+    fn fold_calc_product(
+        &mut self,
+        node: CalcProduct,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProduct {
+        <V as FoldAstPath>::fold_calc_product(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
-        <V as VisitAll>::visit_attribute_selector_matcher(&mut **self, node)
+    fn fold_calc_product_or_operator(
+        &mut self,
+        node: CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProductOrOperator {
+        <V as FoldAstPath>::fold_calc_product_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
-        <V as VisitAll>::visit_attribute_selector_matcher_value(&mut **self, node)
+    fn fold_calc_product_or_operators(
+        &mut self,
+        node: Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcProductOrOperator> {
+        <V as FoldAstPath>::fold_calc_product_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
-        <V as VisitAll>::visit_attribute_selector_modifier(&mut **self, node)
+    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
+        <V as FoldAstPath>::fold_calc_sum(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
-        <V as VisitAll>::visit_attribute_selector_value(&mut **self, node)
+    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
+        <V as FoldAstPath>::fold_calc_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_bin_op(&mut self, node: &BinOp) {
-        <V as VisitAll>::visit_bin_op(&mut **self, node)
+    fn fold_calc_value_or_operator(
+        &mut self,
+        node: CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcValueOrOperator {
+        <V as FoldAstPath>::fold_calc_value_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_operator(&mut self, node: &CalcOperator) {
-        <V as VisitAll>::visit_calc_operator(&mut **self, node)
+    fn fold_calc_value_or_operators(
+        &mut self,
+        node: Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcValueOrOperator> {
+        <V as FoldAstPath>::fold_calc_value_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
-        <V as VisitAll>::visit_calc_operator_type(&mut **self, node)
+    fn fold_class_selector(
+        &mut self,
+        node: ClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassSelector {
+        <V as FoldAstPath>::fold_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_product(&mut self, node: &CalcProduct) {
-        <V as VisitAll>::visit_calc_product(&mut **self, node)
+    fn fold_cmyk_component(
+        &mut self,
+        node: CmykComponent,
+        __ast_path: &mut AstKindPath,
+    ) -> CmykComponent {
+        <V as FoldAstPath>::fold_cmyk_component(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
-        <V as VisitAll>::visit_calc_product_or_operator(&mut **self, node)
+    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
+        <V as FoldAstPath>::fold_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
-        <V as VisitAll>::visit_calc_product_or_operators(&mut **self, node)
+    fn fold_color_profile_name(
+        &mut self,
+        node: ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) -> ColorProfileName {
+        <V as FoldAstPath>::fold_color_profile_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_sum(&mut self, node: &CalcSum) {
-        <V as VisitAll>::visit_calc_sum(&mut **self, node)
+    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
+        <V as FoldAstPath>::fold_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_value(&mut self, node: &CalcValue) {
-        <V as VisitAll>::visit_calc_value(&mut **self, node)
+    fn fold_combinator_value(
+        &mut self,
+        node: CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> CombinatorValue {
+        <V as FoldAstPath>::fold_combinator_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
-        <V as VisitAll>::visit_calc_value_or_operator(&mut **self, node)
+    fn fold_complex_selector(
+        &mut self,
+        node: ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelector {
+        <V as FoldAstPath>::fold_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
-        <V as VisitAll>::visit_calc_value_or_operators(&mut **self, node)
+    fn fold_complex_selector_children(
+        &mut self,
+        node: ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelectorChildren {
+        <V as FoldAstPath>::fold_complex_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_selector(&mut self, node: &ClassSelector) {
-        <V as VisitAll>::visit_class_selector(&mut **self, node)
+    fn fold_complex_selector_childrens(
+        &mut self,
+        node: Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelectorChildren> {
+        <V as FoldAstPath>::fold_complex_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_cmyk_component(&mut self, node: &CmykComponent) {
-        <V as VisitAll>::visit_cmyk_component(&mut **self, node)
+    fn fold_complex_selectors(
+        &mut self,
+        node: Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelector> {
+        <V as FoldAstPath>::fold_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_color(&mut self, node: &Color) {
-        <V as VisitAll>::visit_color(&mut **self, node)
+    fn fold_component_value(
+        &mut self,
+        node: ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) -> ComponentValue {
+        <V as FoldAstPath>::fold_component_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
-        <V as VisitAll>::visit_color_profile_name(&mut **self, node)
+    fn fold_component_values(
+        &mut self,
+        node: Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComponentValue> {
+        <V as FoldAstPath>::fold_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_combinator(&mut self, node: &Combinator) {
-        <V as VisitAll>::visit_combinator(&mut **self, node)
+    fn fold_compound_selector(
+        &mut self,
+        node: CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelector {
+        <V as FoldAstPath>::fold_compound_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_combinator_value(&mut self, node: &CombinatorValue) {
-        <V as VisitAll>::visit_combinator_value(&mut **self, node)
+    fn fold_compound_selector_list(
+        &mut self,
+        node: CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelectorList {
+        <V as FoldAstPath>::fold_compound_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selector(&mut self, node: &ComplexSelector) {
-        <V as VisitAll>::visit_complex_selector(&mut **self, node)
+    fn fold_compound_selectors(
+        &mut self,
+        node: Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CompoundSelector> {
+        <V as FoldAstPath>::fold_compound_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
-        <V as VisitAll>::visit_complex_selector_children(&mut **self, node)
+    fn fold_container_condition(
+        &mut self,
+        node: ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerCondition {
+        <V as FoldAstPath>::fold_container_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
-        <V as VisitAll>::visit_complex_selector_childrens(&mut **self, node)
+    fn fold_container_name(
+        &mut self,
+        node: ContainerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerName {
+        <V as FoldAstPath>::fold_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
-        <V as VisitAll>::visit_complex_selectors(&mut **self, node)
+    fn fold_container_query(
+        &mut self,
+        node: ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQuery {
+        <V as FoldAstPath>::fold_container_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_component_value(&mut self, node: &ComponentValue) {
-        <V as VisitAll>::visit_component_value(&mut **self, node)
+    fn fold_container_query_and(
+        &mut self,
+        node: ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryAnd {
+        <V as FoldAstPath>::fold_container_query_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_component_values(&mut self, node: &[ComponentValue]) {
-        <V as VisitAll>::visit_component_values(&mut **self, node)
+    fn fold_container_query_not(
+        &mut self,
+        node: ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryNot {
+        <V as FoldAstPath>::fold_container_query_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_compound_selector(&mut self, node: &CompoundSelector) {
-        <V as VisitAll>::visit_compound_selector(&mut **self, node)
+    fn fold_container_query_or(
+        &mut self,
+        node: ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryOr {
+        <V as FoldAstPath>::fold_container_query_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
-        <V as VisitAll>::visit_compound_selector_list(&mut **self, node)
+    fn fold_container_query_type(
+        &mut self,
+        node: ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryType {
+        <V as FoldAstPath>::fold_container_query_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
-        <V as VisitAll>::visit_compound_selectors(&mut **self, node)
+    fn fold_container_query_types(
+        &mut self,
+        node: Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ContainerQueryType> {
+        <V as FoldAstPath>::fold_container_query_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_condition(&mut self, node: &ContainerCondition) {
-        <V as VisitAll>::visit_container_condition(&mut **self, node)
+    fn fold_custom_highlight_name(
+        &mut self,
+        node: CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomHighlightName {
+        <V as FoldAstPath>::fold_custom_highlight_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_name(&mut self, node: &ContainerName) {
-        <V as VisitAll>::visit_container_name(&mut **self, node)
+    fn fold_custom_ident(
+        &mut self,
+        node: CustomIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomIdent {
+        <V as FoldAstPath>::fold_custom_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query(&mut self, node: &ContainerQuery) {
-        <V as VisitAll>::visit_container_query(&mut **self, node)
+    fn fold_custom_idents(
+        &mut self,
+        node: Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CustomIdent> {
+        <V as FoldAstPath>::fold_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
-        <V as VisitAll>::visit_container_query_and(&mut **self, node)
+    fn fold_custom_media_query(
+        &mut self,
+        node: CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQuery {
+        <V as FoldAstPath>::fold_custom_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
-        <V as VisitAll>::visit_container_query_not(&mut **self, node)
+    fn fold_custom_media_query_media_type(
+        &mut self,
+        node: CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQueryMediaType {
+        <V as FoldAstPath>::fold_custom_media_query_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
-        <V as VisitAll>::visit_container_query_or(&mut **self, node)
+    fn fold_custom_property_name(
+        &mut self,
+        node: CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomPropertyName {
+        <V as FoldAstPath>::fold_custom_property_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
-        <V as VisitAll>::visit_container_query_type(&mut **self, node)
+    fn fold_dashed_ident(
+        &mut self,
+        node: DashedIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> DashedIdent {
+        <V as FoldAstPath>::fold_dashed_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
-        <V as VisitAll>::visit_container_query_types(&mut **self, node)
+    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
+        <V as FoldAstPath>::fold_declaration(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
-        <V as VisitAll>::visit_custom_highlight_name(&mut **self, node)
+    fn fold_declaration_name(
+        &mut self,
+        node: DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationName {
+        <V as FoldAstPath>::fold_declaration_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_ident(&mut self, node: &CustomIdent) {
-        <V as VisitAll>::visit_custom_ident(&mut **self, node)
+    fn fold_declaration_or_at_rule(
+        &mut self,
+        node: DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationOrAtRule {
+        <V as FoldAstPath>::fold_declaration_or_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
-        <V as VisitAll>::visit_custom_idents(&mut **self, node)
+    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
+        <V as FoldAstPath>::fold_delimiter(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
-        <V as VisitAll>::visit_custom_media_query(&mut **self, node)
+    fn fold_delimiter_value(
+        &mut self,
+        node: DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) -> DelimiterValue {
+        <V as FoldAstPath>::fold_delimiter_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_media_query_media_type(&mut self, node: &CustomMediaQueryMediaType) {
-        <V as VisitAll>::visit_custom_media_query_media_type(&mut **self, node)
+    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
+        <V as FoldAstPath>::fold_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
-        <V as VisitAll>::visit_custom_property_name(&mut **self, node)
+    fn fold_dimension_token(
+        &mut self,
+        node: DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) -> DimensionToken {
+        <V as FoldAstPath>::fold_dimension_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_dashed_ident(&mut self, node: &DashedIdent) {
-        <V as VisitAll>::visit_dashed_ident(&mut **self, node)
+    fn fold_document_prelude(
+        &mut self,
+        node: DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPrelude {
+        <V as FoldAstPath>::fold_document_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_declaration(&mut self, node: &Declaration) {
-        <V as VisitAll>::visit_declaration(&mut **self, node)
+    fn fold_document_prelude_matching_function(
+        &mut self,
+        node: DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPreludeMatchingFunction {
+        <V as FoldAstPath>::fold_document_prelude_matching_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_declaration_name(&mut self, node: &DeclarationName) {
-        <V as VisitAll>::visit_declaration_name(&mut **self, node)
+    fn fold_document_prelude_matching_functions(
+        &mut self,
+        node: Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<DocumentPreludeMatchingFunction> {
+        <V as FoldAstPath>::fold_document_prelude_matching_functions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
-        <V as VisitAll>::visit_declaration_or_at_rule(&mut **self, node)
+    fn fold_extension_name(
+        &mut self,
+        node: ExtensionName,
+        __ast_path: &mut AstKindPath,
+    ) -> ExtensionName {
+        <V as FoldAstPath>::fold_extension_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_delimiter(&mut self, node: &Delimiter) {
-        <V as VisitAll>::visit_delimiter(&mut **self, node)
+    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
+        <V as FoldAstPath>::fold_family_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
-        <V as VisitAll>::visit_delimiter_value(&mut **self, node)
+    fn fold_family_names(
+        &mut self,
+        node: Vec<FamilyName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<FamilyName> {
+        <V as FoldAstPath>::fold_family_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_dimension(&mut self, node: &Dimension) {
-        <V as VisitAll>::visit_dimension(&mut **self, node)
+    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
+        <V as FoldAstPath>::fold_flex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_dimension_token(&mut self, node: &DimensionToken) {
-        <V as VisitAll>::visit_dimension_token(&mut **self, node)
+    fn fold_font_feature_values_prelude(
+        &mut self,
+        node: FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> FontFeatureValuesPrelude {
+        <V as FoldAstPath>::fold_font_feature_values_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
-        <V as VisitAll>::visit_document_prelude(&mut **self, node)
+    fn fold_forgiving_complex_selector(
+        &mut self,
+        node: ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingComplexSelector {
+        <V as FoldAstPath>::fold_forgiving_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_document_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
-        <V as VisitAll>::visit_document_prelude_matching_function(&mut **self, node)
+    fn fold_forgiving_complex_selectors(
+        &mut self,
+        node: Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingComplexSelector> {
+        <V as FoldAstPath>::fold_forgiving_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_document_prelude_matching_functions(
+    fn fold_forgiving_relative_selector(
         &mut self,
-        node: &[DocumentPreludeMatchingFunction],
-    ) {
-        <V as VisitAll>::visit_document_prelude_matching_functions(&mut **self, node)
+        node: ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelector {
+        <V as FoldAstPath>::fold_forgiving_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_extension_name(&mut self, node: &ExtensionName) {
-        <V as VisitAll>::visit_extension_name(&mut **self, node)
+    fn fold_forgiving_relative_selector_list(
+        &mut self,
+        node: ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelectorList {
+        <V as FoldAstPath>::fold_forgiving_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_family_name(&mut self, node: &FamilyName) {
-        <V as VisitAll>::visit_family_name(&mut **self, node)
+    fn fold_forgiving_relative_selectors(
+        &mut self,
+        node: Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingRelativeSelector> {
+        <V as FoldAstPath>::fold_forgiving_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_family_names(&mut self, node: &[FamilyName]) {
-        <V as VisitAll>::visit_family_names(&mut **self, node)
+    fn fold_forgiving_selector_list(
+        &mut self,
+        node: ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingSelectorList {
+        <V as FoldAstPath>::fold_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_flex(&mut self, node: &Flex) {
-        <V as VisitAll>::visit_flex(&mut **self, node)
+    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
+        <V as FoldAstPath>::fold_frequency(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
-        <V as VisitAll>::visit_font_feature_values_prelude(&mut **self, node)
+    fn fold_frequency_percentage(
+        &mut self,
+        node: FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> FrequencyPercentage {
+        <V as FoldAstPath>::fold_frequency_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
-        <V as VisitAll>::visit_forgiving_complex_selector(&mut **self, node)
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
-        <V as VisitAll>::visit_forgiving_complex_selectors(&mut **self, node)
+    fn fold_function_name(
+        &mut self,
+        node: FunctionName,
+        __ast_path: &mut AstKindPath,
+    ) -> FunctionName {
+        <V as FoldAstPath>::fold_function_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
-        <V as VisitAll>::visit_forgiving_relative_selector(&mut **self, node)
+    fn fold_general_enclosed(
+        &mut self,
+        node: GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) -> GeneralEnclosed {
+        <V as FoldAstPath>::fold_general_enclosed(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
-        <V as VisitAll>::visit_forgiving_relative_selector_list(&mut **self, node)
+    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
+        <V as FoldAstPath>::fold_hex_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
-        <V as VisitAll>::visit_forgiving_relative_selectors(&mut **self, node)
+    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
+        <V as FoldAstPath>::fold_hue(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
-        <V as VisitAll>::visit_forgiving_selector_list(&mut **self, node)
+    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
+        <V as FoldAstPath>::fold_id_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_frequency(&mut self, node: &Frequency) {
-        <V as VisitAll>::visit_frequency(&mut **self, node)
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
-        <V as VisitAll>::visit_frequency_percentage(&mut **self, node)
+    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
+        <V as FoldAstPath>::fold_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <V as VisitAll>::visit_function(&mut **self, node)
+    fn fold_import_conditions(
+        &mut self,
+        node: ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportConditions {
+        <V as FoldAstPath>::fold_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_function_name(&mut self, node: &FunctionName) {
-        <V as VisitAll>::visit_function_name(&mut **self, node)
+    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
+        <V as FoldAstPath>::fold_import_href(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
-        <V as VisitAll>::visit_general_enclosed(&mut **self, node)
+    fn fold_import_layer_name(
+        &mut self,
+        node: ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportLayerName {
+        <V as FoldAstPath>::fold_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_hex_color(&mut self, node: &HexColor) {
-        <V as VisitAll>::visit_hex_color(&mut **self, node)
+    fn fold_import_prelude(
+        &mut self,
+        node: ImportPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPrelude {
+        <V as FoldAstPath>::fold_import_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_hue(&mut self, node: &Hue) {
-        <V as VisitAll>::visit_hue(&mut **self, node)
+    fn fold_important_flag(
+        &mut self,
+        node: ImportantFlag,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportantFlag {
+        <V as FoldAstPath>::fold_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_id_selector(&mut self, node: &IdSelector) {
-        <V as VisitAll>::visit_id_selector(&mut **self, node)
+    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
+        <V as FoldAstPath>::fold_integer(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <V as VisitAll>::visit_ident(&mut **self, node)
+    fn fold_keyframe_block(
+        &mut self,
+        node: KeyframeBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeBlock {
+        <V as FoldAstPath>::fold_keyframe_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_idents(&mut self, node: &[Ident]) {
-        <V as VisitAll>::visit_idents(&mut **self, node)
+    fn fold_keyframe_selector(
+        &mut self,
+        node: KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeSelector {
+        <V as FoldAstPath>::fold_keyframe_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_conditions(&mut self, node: &ImportConditions) {
-        <V as VisitAll>::visit_import_conditions(&mut **self, node)
+    fn fold_keyframe_selectors(
+        &mut self,
+        node: Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<KeyframeSelector> {
+        <V as FoldAstPath>::fold_keyframe_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_href(&mut self, node: &ImportHref) {
-        <V as VisitAll>::visit_import_href(&mut **self, node)
+    fn fold_keyframes_name(
+        &mut self,
+        node: KeyframesName,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesName {
+        <V as FoldAstPath>::fold_keyframes_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
-        <V as VisitAll>::visit_import_layer_name(&mut **self, node)
+    fn fold_keyframes_pseudo_function(
+        &mut self,
+        node: KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoFunction {
+        <V as FoldAstPath>::fold_keyframes_pseudo_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_prelude(&mut self, node: &ImportPrelude) {
-        <V as VisitAll>::visit_import_prelude(&mut **self, node)
+    fn fold_keyframes_pseudo_prefix(
+        &mut self,
+        node: KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoPrefix {
+        <V as FoldAstPath>::fold_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_important_flag(&mut self, node: &ImportantFlag) {
-        <V as VisitAll>::visit_important_flag(&mut **self, node)
+    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
+        <V as FoldAstPath>::fold_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_integer(&mut self, node: &Integer) {
-        <V as VisitAll>::visit_integer(&mut **self, node)
+    fn fold_layer_name_list(
+        &mut self,
+        node: LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerNameList {
+        <V as FoldAstPath>::fold_layer_name_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
-        <V as VisitAll>::visit_keyframe_block(&mut **self, node)
+    fn fold_layer_names(
+        &mut self,
+        node: Vec<LayerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<LayerName> {
+        <V as FoldAstPath>::fold_layer_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
-        <V as VisitAll>::visit_keyframe_selector(&mut **self, node)
+    fn fold_layer_prelude(
+        &mut self,
+        node: LayerPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerPrelude {
+        <V as FoldAstPath>::fold_layer_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
-        <V as VisitAll>::visit_keyframe_selectors(&mut **self, node)
+    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
+        <V as FoldAstPath>::fold_length(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframes_name(&mut self, node: &KeyframesName) {
-        <V as VisitAll>::visit_keyframes_name(&mut **self, node)
+    fn fold_length_percentage(
+        &mut self,
+        node: LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> LengthPercentage {
+        <V as FoldAstPath>::fold_length_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
-        <V as VisitAll>::visit_keyframes_pseudo_function(&mut **self, node)
+    fn fold_list_of_component_values(
+        &mut self,
+        node: ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) -> ListOfComponentValues {
+        <V as FoldAstPath>::fold_list_of_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
-        <V as VisitAll>::visit_keyframes_pseudo_prefix(&mut **self, node)
+    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
+        <V as FoldAstPath>::fold_media_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_name(&mut self, node: &LayerName) {
-        <V as VisitAll>::visit_layer_name(&mut **self, node)
+    fn fold_media_condition(
+        &mut self,
+        node: MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaCondition {
+        <V as FoldAstPath>::fold_media_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_name_list(&mut self, node: &LayerNameList) {
-        <V as VisitAll>::visit_layer_name_list(&mut **self, node)
+    fn fold_media_condition_all_type(
+        &mut self,
+        node: MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionAllType {
+        <V as FoldAstPath>::fold_media_condition_all_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_names(&mut self, node: &[LayerName]) {
-        <V as VisitAll>::visit_layer_names(&mut **self, node)
+    fn fold_media_condition_all_types(
+        &mut self,
+        node: Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionAllType> {
+        <V as FoldAstPath>::fold_media_condition_all_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
-        <V as VisitAll>::visit_layer_prelude(&mut **self, node)
+    fn fold_media_condition_type(
+        &mut self,
+        node: MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionType {
+        <V as FoldAstPath>::fold_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_length(&mut self, node: &Length) {
-        <V as VisitAll>::visit_length(&mut **self, node)
+    fn fold_media_condition_without_or(
+        &mut self,
+        node: MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOr {
+        <V as FoldAstPath>::fold_media_condition_without_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_length_percentage(&mut self, node: &LengthPercentage) {
-        <V as VisitAll>::visit_length_percentage(&mut **self, node)
+    fn fold_media_condition_without_or_type(
+        &mut self,
+        node: MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOrType {
+        <V as FoldAstPath>::fold_media_condition_without_or_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
-        <V as VisitAll>::visit_list_of_component_values(&mut **self, node)
+    fn fold_media_condition_without_or_types(
+        &mut self,
+        node: Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionWithoutOrType> {
+        <V as FoldAstPath>::fold_media_condition_without_or_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_and(&mut self, node: &MediaAnd) {
-        <V as VisitAll>::visit_media_and(&mut **self, node)
+    fn fold_media_feature(
+        &mut self,
+        node: MediaFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeature {
+        <V as FoldAstPath>::fold_media_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition(&mut self, node: &MediaCondition) {
-        <V as VisitAll>::visit_media_condition(&mut **self, node)
+    fn fold_media_feature_boolean(
+        &mut self,
+        node: MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureBoolean {
+        <V as FoldAstPath>::fold_media_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
-        <V as VisitAll>::visit_media_condition_all_type(&mut **self, node)
+    fn fold_media_feature_name(
+        &mut self,
+        node: MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureName {
+        <V as FoldAstPath>::fold_media_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
-        <V as VisitAll>::visit_media_condition_all_types(&mut **self, node)
+    fn fold_media_feature_plain(
+        &mut self,
+        node: MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeaturePlain {
+        <V as FoldAstPath>::fold_media_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
-        <V as VisitAll>::visit_media_condition_type(&mut **self, node)
+    fn fold_media_feature_range(
+        &mut self,
+        node: MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRange {
+        <V as FoldAstPath>::fold_media_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
-        <V as VisitAll>::visit_media_condition_without_or(&mut **self, node)
+    fn fold_media_feature_range_comparison(
+        &mut self,
+        node: MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeComparison {
+        <V as FoldAstPath>::fold_media_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_without_or_type(&mut self, node: &MediaConditionWithoutOrType) {
-        <V as VisitAll>::visit_media_condition_without_or_type(&mut **self, node)
+    fn fold_media_feature_range_interval(
+        &mut self,
+        node: MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeInterval {
+        <V as FoldAstPath>::fold_media_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_without_or_types(&mut self, node: &[MediaConditionWithoutOrType]) {
-        <V as VisitAll>::visit_media_condition_without_or_types(&mut **self, node)
+    fn fold_media_feature_value(
+        &mut self,
+        node: MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureValue {
+        <V as FoldAstPath>::fold_media_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature(&mut self, node: &MediaFeature) {
-        <V as VisitAll>::visit_media_feature(&mut **self, node)
+    fn fold_media_in_parens(
+        &mut self,
+        node: MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaInParens {
+        <V as FoldAstPath>::fold_media_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
-        <V as VisitAll>::visit_media_feature_boolean(&mut **self, node)
+    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
+        <V as FoldAstPath>::fold_media_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
-        <V as VisitAll>::visit_media_feature_name(&mut **self, node)
+    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
+        <V as FoldAstPath>::fold_media_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
-        <V as VisitAll>::visit_media_feature_plain(&mut **self, node)
+    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
+        <V as FoldAstPath>::fold_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
-        <V as VisitAll>::visit_media_feature_range(&mut **self, node)
+    fn fold_media_query_list(
+        &mut self,
+        node: MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaQueryList {
+        <V as FoldAstPath>::fold_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
-        <V as VisitAll>::visit_media_feature_range_comparison(&mut **self, node)
+    fn fold_media_querys(
+        &mut self,
+        node: Vec<MediaQuery>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaQuery> {
+        <V as FoldAstPath>::fold_media_querys(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
-        <V as VisitAll>::visit_media_feature_range_interval(&mut **self, node)
+    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
+        <V as FoldAstPath>::fold_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
-        <V as VisitAll>::visit_media_feature_value(&mut **self, node)
+    fn fold_named_namespace(
+        &mut self,
+        node: NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedNamespace {
+        <V as FoldAstPath>::fold_named_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_in_parens(&mut self, node: &MediaInParens) {
-        <V as VisitAll>::visit_media_in_parens(&mut **self, node)
+    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
+        <V as FoldAstPath>::fold_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_not(&mut self, node: &MediaNot) {
-        <V as VisitAll>::visit_media_not(&mut **self, node)
+    fn fold_namespace_prefix(
+        &mut self,
+        node: NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrefix {
+        <V as FoldAstPath>::fold_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_or(&mut self, node: &MediaOr) {
-        <V as VisitAll>::visit_media_or(&mut **self, node)
+    fn fold_namespace_prelude(
+        &mut self,
+        node: NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrelude {
+        <V as FoldAstPath>::fold_namespace_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_query(&mut self, node: &MediaQuery) {
-        <V as VisitAll>::visit_media_query(&mut **self, node)
+    fn fold_namespace_prelude_uri(
+        &mut self,
+        node: NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePreludeUri {
+        <V as FoldAstPath>::fold_namespace_prelude_uri(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_query_list(&mut self, node: &MediaQueryList) {
-        <V as VisitAll>::visit_media_query_list(&mut **self, node)
+    fn fold_nesting_selector(
+        &mut self,
+        node: NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> NestingSelector {
+        <V as FoldAstPath>::fold_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_querys(&mut self, node: &[MediaQuery]) {
-        <V as VisitAll>::visit_media_querys(&mut **self, node)
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_type(&mut self, node: &MediaType) {
-        <V as VisitAll>::visit_media_type(&mut **self, node)
+    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
+        <V as FoldAstPath>::fold_number_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_named_namespace(&mut self, node: &NamedNamespace) {
-        <V as VisitAll>::visit_named_namespace(&mut **self, node)
+    fn fold_opt_at_rule_prelude(
+        &mut self,
+        node: Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<AtRulePrelude>> {
+        <V as FoldAstPath>::fold_opt_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut **self, node)
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
+        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
-        <V as VisitAll>::visit_namespace_prefix(&mut **self, node)
+    fn fold_opt_attribute_selector_matcher(
+        &mut self,
+        node: Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorMatcher> {
+        <V as FoldAstPath>::fold_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
-        <V as VisitAll>::visit_namespace_prelude(&mut **self, node)
+    fn fold_opt_attribute_selector_modifier(
+        &mut self,
+        node: Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorModifier> {
+        <V as FoldAstPath>::fold_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
-        <V as VisitAll>::visit_namespace_prelude_uri(&mut **self, node)
+    fn fold_opt_attribute_selector_value(
+        &mut self,
+        node: Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorValue> {
+        <V as FoldAstPath>::fold_opt_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_nesting_selector(&mut self, node: &NestingSelector) {
-        <V as VisitAll>::visit_nesting_selector(&mut **self, node)
+    fn fold_opt_combinator(
+        &mut self,
+        node: Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Combinator> {
+        <V as FoldAstPath>::fold_opt_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <V as VisitAll>::visit_number(&mut **self, node)
+    fn fold_opt_container_name(
+        &mut self,
+        node: Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ContainerName> {
+        <V as FoldAstPath>::fold_opt_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_number_type(&mut self, node: &NumberType) {
-        <V as VisitAll>::visit_number_type(&mut **self, node)
+    fn fold_opt_forgiving_selector_list(
+        &mut self,
+        node: Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ForgivingSelectorList> {
+        <V as FoldAstPath>::fold_opt_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>) {
-        <V as VisitAll>::visit_opt_at_rule_prelude(&mut **self, node)
+    fn fold_opt_function(
+        &mut self,
+        node: Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Function>> {
+        <V as FoldAstPath>::fold_opt_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
+        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_matcher(&mut self, node: &Option<AttributeSelectorMatcher>) {
-        <V as VisitAll>::visit_opt_attribute_selector_matcher(&mut **self, node)
+    fn fold_opt_import_conditions(
+        &mut self,
+        node: Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportConditions>> {
+        <V as FoldAstPath>::fold_opt_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_modifier(&mut self, node: &Option<AttributeSelectorModifier>) {
-        <V as VisitAll>::visit_opt_attribute_selector_modifier(&mut **self, node)
+    fn fold_opt_import_layer_name(
+        &mut self,
+        node: Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportLayerName>> {
+        <V as FoldAstPath>::fold_opt_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_value(&mut self, node: &Option<AttributeSelectorValue>) {
-        <V as VisitAll>::visit_opt_attribute_selector_value(&mut **self, node)
+    fn fold_opt_important_flag(
+        &mut self,
+        node: Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ImportantFlag> {
+        <V as FoldAstPath>::fold_opt_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
-        <V as VisitAll>::visit_opt_combinator(&mut **self, node)
+    fn fold_opt_media_condition_type(
+        &mut self,
+        node: Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaConditionType>> {
+        <V as FoldAstPath>::fold_opt_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_container_name(&mut self, node: &Option<ContainerName>) {
-        <V as VisitAll>::visit_opt_container_name(&mut **self, node)
+    fn fold_opt_media_query_list(
+        &mut self,
+        node: Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaQueryList>> {
+        <V as FoldAstPath>::fold_opt_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_forgiving_selector_list(&mut self, node: &Option<ForgivingSelectorList>) {
-        <V as VisitAll>::visit_opt_forgiving_selector_list(&mut **self, node)
+    fn fold_opt_media_type(
+        &mut self,
+        node: Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<MediaType> {
+        <V as FoldAstPath>::fold_opt_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_function(&mut self, node: &Option<Box<Function>>) {
-        <V as VisitAll>::visit_opt_function(&mut **self, node)
+    fn fold_opt_namespace(
+        &mut self,
+        node: Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Namespace> {
+        <V as FoldAstPath>::fold_opt_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <V as VisitAll>::visit_opt_ident(&mut **self, node)
+    fn fold_opt_namespace_prefix(
+        &mut self,
+        node: Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NamespacePrefix> {
+        <V as FoldAstPath>::fold_opt_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>) {
-        <V as VisitAll>::visit_opt_import_conditions(&mut **self, node)
+    fn fold_opt_nesting_selector(
+        &mut self,
+        node: Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NestingSelector> {
+        <V as FoldAstPath>::fold_opt_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>) {
-        <V as VisitAll>::visit_opt_import_layer_name(&mut **self, node)
+    fn fold_opt_number(
+        &mut self,
+        node: Option<Number>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Number> {
+        <V as FoldAstPath>::fold_opt_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>) {
-        <V as VisitAll>::visit_opt_important_flag(&mut **self, node)
+    fn fold_opt_page_selector_pseudos(
+        &mut self,
+        node: Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PageSelectorPseudo>> {
+        <V as FoldAstPath>::fold_opt_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_media_condition_type(&mut self, node: &Option<Box<MediaConditionType>>) {
-        <V as VisitAll>::visit_opt_media_condition_type(&mut **self, node)
+    fn fold_opt_page_selector_type(
+        &mut self,
+        node: Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<PageSelectorType> {
+        <V as FoldAstPath>::fold_opt_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>) {
-        <V as VisitAll>::visit_opt_media_query_list(&mut **self, node)
+    fn fold_opt_pseudo_class_selector_childrens(
+        &mut self,
+        node: Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoClassSelectorChildren>> {
+        <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_media_type(&mut self, node: &Option<MediaType>) {
-        <V as VisitAll>::visit_opt_media_type(&mut **self, node)
+    fn fold_opt_pseudo_element_selector_childrens(
+        &mut self,
+        node: Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoElementSelectorChildren>> {
+        <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut **self, node)
+    fn fold_opt_simple_block(
+        &mut self,
+        node: Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<SimpleBlock> {
+        <V as FoldAstPath>::fold_opt_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_namespace_prefix(&mut self, node: &Option<NamespacePrefix>) {
-        <V as VisitAll>::visit_opt_namespace_prefix(&mut **self, node)
+    fn fold_opt_type_selector(
+        &mut self,
+        node: Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TypeSelector>> {
+        <V as FoldAstPath>::fold_opt_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_nesting_selector(&mut self, node: &Option<NestingSelector>) {
-        <V as VisitAll>::visit_opt_nesting_selector(&mut **self, node)
+    fn fold_opt_url_modifiers(
+        &mut self,
+        node: Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<UrlModifier>> {
+        <V as FoldAstPath>::fold_opt_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_number(&mut self, node: &Option<Number>) {
-        <V as VisitAll>::visit_opt_number(&mut **self, node)
+    fn fold_opt_url_value(
+        &mut self,
+        node: Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<UrlValue>> {
+        <V as FoldAstPath>::fold_opt_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_page_selector_pseudos(&mut self, node: &Option<Vec<PageSelectorPseudo>>) {
-        <V as VisitAll>::visit_opt_page_selector_pseudos(&mut **self, node)
+    fn fold_page_selector(
+        &mut self,
+        node: PageSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelector {
+        <V as FoldAstPath>::fold_page_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_page_selector_type(&mut self, node: &Option<PageSelectorType>) {
-        <V as VisitAll>::visit_opt_page_selector_type(&mut **self, node)
+    fn fold_page_selector_list(
+        &mut self,
+        node: PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorList {
+        <V as FoldAstPath>::fold_page_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_pseudo_class_selector_childrens(
+    fn fold_page_selector_pseudo(
         &mut self,
-        node: &Option<Vec<PseudoClassSelectorChildren>>,
-    ) {
-        <V as VisitAll>::visit_opt_pseudo_class_selector_childrens(&mut **self, node)
+        node: PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorPseudo {
+        <V as FoldAstPath>::fold_page_selector_pseudo(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_pseudo_element_selector_childrens(
+    fn fold_page_selector_pseudos(
         &mut self,
-        node: &Option<Vec<PseudoElementSelectorChildren>>,
-    ) {
-        <V as VisitAll>::visit_opt_pseudo_element_selector_childrens(&mut **self, node)
+        node: Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelectorPseudo> {
+        <V as FoldAstPath>::fold_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>) {
-        <V as VisitAll>::visit_opt_simple_block(&mut **self, node)
+    fn fold_page_selector_type(
+        &mut self,
+        node: PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorType {
+        <V as FoldAstPath>::fold_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>) {
-        <V as VisitAll>::visit_opt_type_selector(&mut **self, node)
+    fn fold_page_selectors(
+        &mut self,
+        node: Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelector> {
+        <V as FoldAstPath>::fold_page_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>) {
-        <V as VisitAll>::visit_opt_url_modifiers(&mut **self, node)
+    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
+        <V as FoldAstPath>::fold_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_url_value(&mut self, node: &Option<Box<UrlValue>>) {
-        <V as VisitAll>::visit_opt_url_value(&mut **self, node)
+    fn fold_pseudo_class_selector(
+        &mut self,
+        node: PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelector {
+        <V as FoldAstPath>::fold_pseudo_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector(&mut self, node: &PageSelector) {
-        <V as VisitAll>::visit_page_selector(&mut **self, node)
+    fn fold_pseudo_class_selector_children(
+        &mut self,
+        node: PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelectorChildren {
+        <V as FoldAstPath>::fold_pseudo_class_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
-        <V as VisitAll>::visit_page_selector_list(&mut **self, node)
+    fn fold_pseudo_class_selector_childrens(
+        &mut self,
+        node: Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoClassSelectorChildren> {
+        <V as FoldAstPath>::fold_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
-        <V as VisitAll>::visit_page_selector_pseudo(&mut **self, node)
+    fn fold_pseudo_element_selector(
+        &mut self,
+        node: PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelector {
+        <V as FoldAstPath>::fold_pseudo_element_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
-        <V as VisitAll>::visit_page_selector_pseudos(&mut **self, node)
+    fn fold_pseudo_element_selector_children(
+        &mut self,
+        node: PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelectorChildren {
+        <V as FoldAstPath>::fold_pseudo_element_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
-        <V as VisitAll>::visit_page_selector_type(&mut **self, node)
+    fn fold_pseudo_element_selector_childrens(
+        &mut self,
+        node: Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoElementSelectorChildren> {
+        <V as FoldAstPath>::fold_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selectors(&mut self, node: &[PageSelector]) {
-        <V as VisitAll>::visit_page_selectors(&mut **self, node)
+    fn fold_qualified_rule(
+        &mut self,
+        node: QualifiedRule,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRule {
+        <V as FoldAstPath>::fold_qualified_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_percentage(&mut self, node: &Percentage) {
-        <V as VisitAll>::visit_percentage(&mut **self, node)
+    fn fold_qualified_rule_prelude(
+        &mut self,
+        node: QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRulePrelude {
+        <V as FoldAstPath>::fold_qualified_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
-        <V as VisitAll>::visit_pseudo_class_selector(&mut **self, node)
+    fn fold_query_in_parens(
+        &mut self,
+        node: QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> QueryInParens {
+        <V as FoldAstPath>::fold_query_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
-        <V as VisitAll>::visit_pseudo_class_selector_children(&mut **self, node)
+    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
+        <V as FoldAstPath>::fold_ratio(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
-        <V as VisitAll>::visit_pseudo_class_selector_childrens(&mut **self, node)
+    fn fold_relative_selector(
+        &mut self,
+        node: RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelector {
+        <V as FoldAstPath>::fold_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
-        <V as VisitAll>::visit_pseudo_element_selector(&mut **self, node)
+    fn fold_relative_selector_list(
+        &mut self,
+        node: RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelectorList {
+        <V as FoldAstPath>::fold_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
-        <V as VisitAll>::visit_pseudo_element_selector_children(&mut **self, node)
+    fn fold_relative_selectors(
+        &mut self,
+        node: Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<RelativeSelector> {
+        <V as FoldAstPath>::fold_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
-        <V as VisitAll>::visit_pseudo_element_selector_childrens(&mut **self, node)
+    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
+        <V as FoldAstPath>::fold_resolution(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
-        <V as VisitAll>::visit_qualified_rule(&mut **self, node)
+    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
+        <V as FoldAstPath>::fold_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
-        <V as VisitAll>::visit_qualified_rule_prelude(&mut **self, node)
+    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
+        <V as FoldAstPath>::fold_rules(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_query_in_parens(&mut self, node: &QueryInParens) {
-        <V as VisitAll>::visit_query_in_parens(&mut **self, node)
+    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
+        <V as FoldAstPath>::fold_scope_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ratio(&mut self, node: &Ratio) {
-        <V as VisitAll>::visit_ratio(&mut **self, node)
+    fn fold_selector_list(
+        &mut self,
+        node: SelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> SelectorList {
+        <V as FoldAstPath>::fold_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_relative_selector(&mut self, node: &RelativeSelector) {
-        <V as VisitAll>::visit_relative_selector(&mut **self, node)
+    fn fold_sequence_of_custom_idents(
+        &mut self,
+        node: SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) -> SequenceOfCustomIdents {
+        <V as FoldAstPath>::fold_sequence_of_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
-        <V as VisitAll>::visit_relative_selector_list(&mut **self, node)
+    fn fold_simple_block(
+        &mut self,
+        node: SimpleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleBlock {
+        <V as FoldAstPath>::fold_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
-        <V as VisitAll>::visit_relative_selectors(&mut **self, node)
+    fn fold_size_feature(
+        &mut self,
+        node: SizeFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeature {
+        <V as FoldAstPath>::fold_size_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_resolution(&mut self, node: &Resolution) {
-        <V as VisitAll>::visit_resolution(&mut **self, node)
+    fn fold_size_feature_boolean(
+        &mut self,
+        node: SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureBoolean {
+        <V as FoldAstPath>::fold_size_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_rule(&mut self, node: &Rule) {
-        <V as VisitAll>::visit_rule(&mut **self, node)
+    fn fold_size_feature_name(
+        &mut self,
+        node: SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureName {
+        <V as FoldAstPath>::fold_size_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_rules(&mut self, node: &[Rule]) {
-        <V as VisitAll>::visit_rules(&mut **self, node)
+    fn fold_size_feature_plain(
+        &mut self,
+        node: SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeaturePlain {
+        <V as FoldAstPath>::fold_size_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_scope_range(&mut self, node: &ScopeRange) {
-        <V as VisitAll>::visit_scope_range(&mut **self, node)
+    fn fold_size_feature_range(
+        &mut self,
+        node: SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRange {
+        <V as FoldAstPath>::fold_size_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_selector_list(&mut self, node: &SelectorList) {
-        <V as VisitAll>::visit_selector_list(&mut **self, node)
+    fn fold_size_feature_range_comparison(
+        &mut self,
+        node: SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeComparison {
+        <V as FoldAstPath>::fold_size_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
-        <V as VisitAll>::visit_sequence_of_custom_idents(&mut **self, node)
+    fn fold_size_feature_range_interval(
+        &mut self,
+        node: SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeInterval {
+        <V as FoldAstPath>::fold_size_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_simple_block(&mut self, node: &SimpleBlock) {
-        <V as VisitAll>::visit_simple_block(&mut **self, node)
+    fn fold_size_feature_value(
+        &mut self,
+        node: SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureValue {
+        <V as FoldAstPath>::fold_size_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature(&mut self, node: &SizeFeature) {
-        <V as VisitAll>::visit_size_feature(&mut **self, node)
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
+        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
-        <V as VisitAll>::visit_size_feature_boolean(&mut **self, node)
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
-        <V as VisitAll>::visit_size_feature_name(&mut **self, node)
+    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
+        <V as FoldAstPath>::fold_style_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
-        <V as VisitAll>::visit_size_feature_plain(&mut **self, node)
+    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
+        <V as FoldAstPath>::fold_stylesheet(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
-        <V as VisitAll>::visit_size_feature_range(&mut **self, node)
+    fn fold_subclass_selector(
+        &mut self,
+        node: SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> SubclassSelector {
+        <V as FoldAstPath>::fold_subclass_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
-        <V as VisitAll>::visit_size_feature_range_comparison(&mut **self, node)
+    fn fold_subclass_selectors(
+        &mut self,
+        node: Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SubclassSelector> {
+        <V as FoldAstPath>::fold_subclass_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
-        <V as VisitAll>::visit_size_feature_range_interval(&mut **self, node)
+    fn fold_supports_and(
+        &mut self,
+        node: SupportsAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsAnd {
+        <V as FoldAstPath>::fold_supports_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
-        <V as VisitAll>::visit_size_feature_value(&mut **self, node)
+    fn fold_supports_condition(
+        &mut self,
+        node: SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsCondition {
+        <V as FoldAstPath>::fold_supports_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
+    fn fold_supports_condition_type(
+        &mut self,
+        node: SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsConditionType {
+        <V as FoldAstPath>::fold_supports_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <V as VisitAll>::visit_str(&mut **self, node)
+    fn fold_supports_condition_types(
+        &mut self,
+        node: Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SupportsConditionType> {
+        <V as FoldAstPath>::fold_supports_condition_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_style_block(&mut self, node: &StyleBlock) {
-        <V as VisitAll>::visit_style_block(&mut **self, node)
+    fn fold_supports_feature(
+        &mut self,
+        node: SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsFeature {
+        <V as FoldAstPath>::fold_supports_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_stylesheet(&mut self, node: &Stylesheet) {
-        <V as VisitAll>::visit_stylesheet(&mut **self, node)
+    fn fold_supports_in_parens(
+        &mut self,
+        node: SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsInParens {
+        <V as FoldAstPath>::fold_supports_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
-        <V as VisitAll>::visit_subclass_selector(&mut **self, node)
+    fn fold_supports_not(
+        &mut self,
+        node: SupportsNot,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsNot {
+        <V as FoldAstPath>::fold_supports_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
-        <V as VisitAll>::visit_subclass_selectors(&mut **self, node)
+    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
+        <V as FoldAstPath>::fold_supports_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_and(&mut self, node: &SupportsAnd) {
-        <V as VisitAll>::visit_supports_and(&mut **self, node)
+    fn fold_tag_name_selector(
+        &mut self,
+        node: TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TagNameSelector {
+        <V as FoldAstPath>::fold_tag_name_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_condition(&mut self, node: &SupportsCondition) {
-        <V as VisitAll>::visit_supports_condition(&mut **self, node)
+    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
+        <V as FoldAstPath>::fold_time(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
-        <V as VisitAll>::visit_supports_condition_type(&mut **self, node)
+    fn fold_time_percentage(
+        &mut self,
+        node: TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> TimePercentage {
+        <V as FoldAstPath>::fold_time_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
-        <V as VisitAll>::visit_supports_condition_types(&mut **self, node)
+    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
+        <V as FoldAstPath>::fold_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_feature(&mut self, node: &SupportsFeature) {
-        <V as VisitAll>::visit_supports_feature(&mut **self, node)
+    fn fold_token_and_span(
+        &mut self,
+        node: TokenAndSpan,
+        __ast_path: &mut AstKindPath,
+    ) -> TokenAndSpan {
+        <V as FoldAstPath>::fold_token_and_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
-        <V as VisitAll>::visit_supports_in_parens(&mut **self, node)
+    fn fold_type_selector(
+        &mut self,
+        node: TypeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TypeSelector {
+        <V as FoldAstPath>::fold_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_not(&mut self, node: &SupportsNot) {
-        <V as VisitAll>::visit_supports_not(&mut **self, node)
+    fn fold_unicode_range(
+        &mut self,
+        node: UnicodeRange,
+        __ast_path: &mut AstKindPath,
+    ) -> UnicodeRange {
+        <V as FoldAstPath>::fold_unicode_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_or(&mut self, node: &SupportsOr) {
-        <V as VisitAll>::visit_supports_or(&mut **self, node)
+    fn fold_universal_selector(
+        &mut self,
+        node: UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> UniversalSelector {
+        <V as FoldAstPath>::fold_universal_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
-        <V as VisitAll>::visit_tag_name_selector(&mut **self, node)
+    fn fold_unknown_dimension(
+        &mut self,
+        node: UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) -> UnknownDimension {
+        <V as FoldAstPath>::fold_unknown_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_time(&mut self, node: &Time) {
-        <V as VisitAll>::visit_time(&mut **self, node)
+    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
+        <V as FoldAstPath>::fold_url(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_time_percentage(&mut self, node: &TimePercentage) {
-        <V as VisitAll>::visit_time_percentage(&mut **self, node)
+    fn fold_url_key_value(
+        &mut self,
+        node: UrlKeyValue,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlKeyValue {
+        <V as FoldAstPath>::fold_url_key_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut **self, node)
+    fn fold_url_modifier(
+        &mut self,
+        node: UrlModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlModifier {
+        <V as FoldAstPath>::fold_url_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut **self, node)
+    fn fold_url_modifiers(
+        &mut self,
+        node: Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<UrlModifier> {
+        <V as FoldAstPath>::fold_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_type_selector(&mut self, node: &TypeSelector) {
-        <V as VisitAll>::visit_type_selector(&mut **self, node)
+    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
+        <V as FoldAstPath>::fold_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_unicode_range(&mut self, node: &UnicodeRange) {
-        <V as VisitAll>::visit_unicode_range(&mut **self, node)
+    fn fold_url_value_raw(
+        &mut self,
+        node: UrlValueRaw,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlValueRaw {
+        <V as FoldAstPath>::fold_url_value_raw(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_universal_selector(&mut self, node: &UniversalSelector) {
-        <V as VisitAll>::visit_universal_selector(&mut **self, node)
+    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
+        <V as FoldAstPath>::fold_wq_name(&mut **self, node, __ast_path)
     }
-
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> FoldAstPath for Box<V>
+where
+    V: ?Sized + FoldAstPath,
+{
     #[inline]
-    fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
-        <V as VisitAll>::visit_unknown_dimension(&mut **self, node)
+    fn fold_absolute_color_base(
+        &mut self,
+        node: AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) -> AbsoluteColorBase {
+        <V as FoldAstPath>::fold_absolute_color_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_url(&mut self, node: &Url) {
-        <V as VisitAll>::visit_url(&mut **self, node)
+    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
+        <V as FoldAstPath>::fold_alpha_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
-        <V as VisitAll>::visit_url_key_value(&mut **self, node)
+    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
+        <V as FoldAstPath>::fold_an_plus_b(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_url_modifier(&mut self, node: &UrlModifier) {
-        <V as VisitAll>::visit_url_modifier(&mut **self, node)
+    fn fold_an_plus_b_notation(
+        &mut self,
+        node: AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) -> AnPlusBNotation {
+        <V as FoldAstPath>::fold_an_plus_b_notation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
-        <V as VisitAll>::visit_url_modifiers(&mut **self, node)
+    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
+        <V as FoldAstPath>::fold_angle(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_url_value(&mut self, node: &UrlValue) {
-        <V as VisitAll>::visit_url_value(&mut **self, node)
+    fn fold_angle_percentage(
+        &mut self,
+        node: AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> AnglePercentage {
+        <V as FoldAstPath>::fold_angle_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
-        <V as VisitAll>::visit_url_value_raw(&mut **self, node)
+    fn fold_any_namespace(
+        &mut self,
+        node: AnyNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> AnyNamespace {
+        <V as FoldAstPath>::fold_any_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_wq_name(&mut self, node: &WqName) {
-        <V as VisitAll>::visit_wq_name(&mut **self, node)
+    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
+        <V as FoldAstPath>::fold_at_rule(&mut **self, node, __ast_path)
     }
-}
-impl<V> VisitAll for Box<V>
-where
-    V: ?Sized + VisitAll,
-{
+
     #[inline]
-    fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
-        <V as VisitAll>::visit_absolute_color_base(&mut **self, node)
+    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
+        <V as FoldAstPath>::fold_at_rule_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_alpha_value(&mut self, node: &AlphaValue) {
-        <V as VisitAll>::visit_alpha_value(&mut **self, node)
+    fn fold_at_rule_prelude(
+        &mut self,
+        node: AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> AtRulePrelude {
+        <V as FoldAstPath>::fold_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_an_plus_b(&mut self, node: &AnPlusB) {
-        <V as VisitAll>::visit_an_plus_b(&mut **self, node)
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
+        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
-        <V as VisitAll>::visit_an_plus_b_notation(&mut **self, node)
+    fn fold_attribute_selector(
+        &mut self,
+        node: AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelector {
+        <V as FoldAstPath>::fold_attribute_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_angle(&mut self, node: &Angle) {
-        <V as VisitAll>::visit_angle(&mut **self, node)
+    fn fold_attribute_selector_matcher(
+        &mut self,
+        node: AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcher {
+        <V as FoldAstPath>::fold_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
-        <V as VisitAll>::visit_angle_percentage(&mut **self, node)
+    fn fold_attribute_selector_matcher_value(
+        &mut self,
+        node: AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcherValue {
+        <V as FoldAstPath>::fold_attribute_selector_matcher_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_any_namespace(&mut self, node: &AnyNamespace) {
-        <V as VisitAll>::visit_any_namespace(&mut **self, node)
+    fn fold_attribute_selector_modifier(
+        &mut self,
+        node: AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorModifier {
+        <V as FoldAstPath>::fold_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_at_rule(&mut self, node: &AtRule) {
-        <V as VisitAll>::visit_at_rule(&mut **self, node)
+    fn fold_attribute_selector_value(
+        &mut self,
+        node: AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorValue {
+        <V as FoldAstPath>::fold_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_at_rule_name(&mut self, node: &AtRuleName) {
-        <V as VisitAll>::visit_at_rule_name(&mut **self, node)
+    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
+        <V as FoldAstPath>::fold_bin_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
-        <V as VisitAll>::visit_at_rule_prelude(&mut **self, node)
+    fn fold_calc_operator(
+        &mut self,
+        node: CalcOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperator {
+        <V as FoldAstPath>::fold_calc_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
+    fn fold_calc_operator_type(
+        &mut self,
+        node: CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperatorType {
+        <V as FoldAstPath>::fold_calc_operator_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
-        <V as VisitAll>::visit_attribute_selector(&mut **self, node)
+    fn fold_calc_product(
+        &mut self,
+        node: CalcProduct,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProduct {
+        <V as FoldAstPath>::fold_calc_product(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
-        <V as VisitAll>::visit_attribute_selector_matcher(&mut **self, node)
+    fn fold_calc_product_or_operator(
+        &mut self,
+        node: CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProductOrOperator {
+        <V as FoldAstPath>::fold_calc_product_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
-        <V as VisitAll>::visit_attribute_selector_matcher_value(&mut **self, node)
+    fn fold_calc_product_or_operators(
+        &mut self,
+        node: Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcProductOrOperator> {
+        <V as FoldAstPath>::fold_calc_product_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
-        <V as VisitAll>::visit_attribute_selector_modifier(&mut **self, node)
+    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
+        <V as FoldAstPath>::fold_calc_sum(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
-        <V as VisitAll>::visit_attribute_selector_value(&mut **self, node)
+    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
+        <V as FoldAstPath>::fold_calc_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_bin_op(&mut self, node: &BinOp) {
-        <V as VisitAll>::visit_bin_op(&mut **self, node)
+    fn fold_calc_value_or_operator(
+        &mut self,
+        node: CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcValueOrOperator {
+        <V as FoldAstPath>::fold_calc_value_or_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_operator(&mut self, node: &CalcOperator) {
-        <V as VisitAll>::visit_calc_operator(&mut **self, node)
+    fn fold_calc_value_or_operators(
+        &mut self,
+        node: Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcValueOrOperator> {
+        <V as FoldAstPath>::fold_calc_value_or_operators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
-        <V as VisitAll>::visit_calc_operator_type(&mut **self, node)
+    fn fold_class_selector(
+        &mut self,
+        node: ClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassSelector {
+        <V as FoldAstPath>::fold_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_product(&mut self, node: &CalcProduct) {
-        <V as VisitAll>::visit_calc_product(&mut **self, node)
+    fn fold_cmyk_component(
+        &mut self,
+        node: CmykComponent,
+        __ast_path: &mut AstKindPath,
+    ) -> CmykComponent {
+        <V as FoldAstPath>::fold_cmyk_component(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
-        <V as VisitAll>::visit_calc_product_or_operator(&mut **self, node)
+    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
+        <V as FoldAstPath>::fold_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
-        <V as VisitAll>::visit_calc_product_or_operators(&mut **self, node)
+    fn fold_color_profile_name(
+        &mut self,
+        node: ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) -> ColorProfileName {
+        <V as FoldAstPath>::fold_color_profile_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_sum(&mut self, node: &CalcSum) {
-        <V as VisitAll>::visit_calc_sum(&mut **self, node)
+    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
+        <V as FoldAstPath>::fold_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_value(&mut self, node: &CalcValue) {
-        <V as VisitAll>::visit_calc_value(&mut **self, node)
+    fn fold_combinator_value(
+        &mut self,
+        node: CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> CombinatorValue {
+        <V as FoldAstPath>::fold_combinator_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
-        <V as VisitAll>::visit_calc_value_or_operator(&mut **self, node)
+    fn fold_complex_selector(
+        &mut self,
+        node: ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelector {
+        <V as FoldAstPath>::fold_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
-        <V as VisitAll>::visit_calc_value_or_operators(&mut **self, node)
+    fn fold_complex_selector_children(
+        &mut self,
+        node: ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelectorChildren {
+        <V as FoldAstPath>::fold_complex_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_selector(&mut self, node: &ClassSelector) {
-        <V as VisitAll>::visit_class_selector(&mut **self, node)
+    fn fold_complex_selector_childrens(
+        &mut self,
+        node: Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelectorChildren> {
+        <V as FoldAstPath>::fold_complex_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_cmyk_component(&mut self, node: &CmykComponent) {
-        <V as VisitAll>::visit_cmyk_component(&mut **self, node)
+    fn fold_complex_selectors(
+        &mut self,
+        node: Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelector> {
+        <V as FoldAstPath>::fold_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_color(&mut self, node: &Color) {
-        <V as VisitAll>::visit_color(&mut **self, node)
+    fn fold_component_value(
+        &mut self,
+        node: ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) -> ComponentValue {
+        <V as FoldAstPath>::fold_component_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
-        <V as VisitAll>::visit_color_profile_name(&mut **self, node)
+    fn fold_component_values(
+        &mut self,
+        node: Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComponentValue> {
+        <V as FoldAstPath>::fold_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_combinator(&mut self, node: &Combinator) {
-        <V as VisitAll>::visit_combinator(&mut **self, node)
+    fn fold_compound_selector(
+        &mut self,
+        node: CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelector {
+        <V as FoldAstPath>::fold_compound_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_combinator_value(&mut self, node: &CombinatorValue) {
-        <V as VisitAll>::visit_combinator_value(&mut **self, node)
+    fn fold_compound_selector_list(
+        &mut self,
+        node: CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelectorList {
+        <V as FoldAstPath>::fold_compound_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selector(&mut self, node: &ComplexSelector) {
-        <V as VisitAll>::visit_complex_selector(&mut **self, node)
+    fn fold_compound_selectors(
+        &mut self,
+        node: Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CompoundSelector> {
+        <V as FoldAstPath>::fold_compound_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
-        <V as VisitAll>::visit_complex_selector_children(&mut **self, node)
+    fn fold_container_condition(
+        &mut self,
+        node: ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerCondition {
+        <V as FoldAstPath>::fold_container_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
-        <V as VisitAll>::visit_complex_selector_childrens(&mut **self, node)
+    fn fold_container_name(
+        &mut self,
+        node: ContainerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerName {
+        <V as FoldAstPath>::fold_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
-        <V as VisitAll>::visit_complex_selectors(&mut **self, node)
+    fn fold_container_query(
+        &mut self,
+        node: ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQuery {
+        <V as FoldAstPath>::fold_container_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_component_value(&mut self, node: &ComponentValue) {
-        <V as VisitAll>::visit_component_value(&mut **self, node)
+    fn fold_container_query_and(
+        &mut self,
+        node: ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryAnd {
+        <V as FoldAstPath>::fold_container_query_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_component_values(&mut self, node: &[ComponentValue]) {
-        <V as VisitAll>::visit_component_values(&mut **self, node)
+    fn fold_container_query_not(
+        &mut self,
+        node: ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryNot {
+        <V as FoldAstPath>::fold_container_query_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_compound_selector(&mut self, node: &CompoundSelector) {
-        <V as VisitAll>::visit_compound_selector(&mut **self, node)
+    fn fold_container_query_or(
+        &mut self,
+        node: ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryOr {
+        <V as FoldAstPath>::fold_container_query_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
-        <V as VisitAll>::visit_compound_selector_list(&mut **self, node)
+    fn fold_container_query_type(
+        &mut self,
+        node: ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryType {
+        <V as FoldAstPath>::fold_container_query_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
-        <V as VisitAll>::visit_compound_selectors(&mut **self, node)
+    fn fold_container_query_types(
+        &mut self,
+        node: Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ContainerQueryType> {
+        <V as FoldAstPath>::fold_container_query_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_condition(&mut self, node: &ContainerCondition) {
-        <V as VisitAll>::visit_container_condition(&mut **self, node)
+    fn fold_custom_highlight_name(
+        &mut self,
+        node: CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomHighlightName {
+        <V as FoldAstPath>::fold_custom_highlight_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_name(&mut self, node: &ContainerName) {
-        <V as VisitAll>::visit_container_name(&mut **self, node)
+    fn fold_custom_ident(
+        &mut self,
+        node: CustomIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomIdent {
+        <V as FoldAstPath>::fold_custom_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query(&mut self, node: &ContainerQuery) {
-        <V as VisitAll>::visit_container_query(&mut **self, node)
+    fn fold_custom_idents(
+        &mut self,
+        node: Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CustomIdent> {
+        <V as FoldAstPath>::fold_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
-        <V as VisitAll>::visit_container_query_and(&mut **self, node)
+    fn fold_custom_media_query(
+        &mut self,
+        node: CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQuery {
+        <V as FoldAstPath>::fold_custom_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
-        <V as VisitAll>::visit_container_query_not(&mut **self, node)
+    fn fold_custom_media_query_media_type(
+        &mut self,
+        node: CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQueryMediaType {
+        <V as FoldAstPath>::fold_custom_media_query_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
-        <V as VisitAll>::visit_container_query_or(&mut **self, node)
+    fn fold_custom_property_name(
+        &mut self,
+        node: CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomPropertyName {
+        <V as FoldAstPath>::fold_custom_property_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
-        <V as VisitAll>::visit_container_query_type(&mut **self, node)
+    fn fold_dashed_ident(
+        &mut self,
+        node: DashedIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> DashedIdent {
+        <V as FoldAstPath>::fold_dashed_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
-        <V as VisitAll>::visit_container_query_types(&mut **self, node)
+    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
+        <V as FoldAstPath>::fold_declaration(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
-        <V as VisitAll>::visit_custom_highlight_name(&mut **self, node)
+    fn fold_declaration_name(
+        &mut self,
+        node: DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationName {
+        <V as FoldAstPath>::fold_declaration_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_ident(&mut self, node: &CustomIdent) {
-        <V as VisitAll>::visit_custom_ident(&mut **self, node)
+    fn fold_declaration_or_at_rule(
+        &mut self,
+        node: DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationOrAtRule {
+        <V as FoldAstPath>::fold_declaration_or_at_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
-        <V as VisitAll>::visit_custom_idents(&mut **self, node)
+    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
+        <V as FoldAstPath>::fold_delimiter(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
-        <V as VisitAll>::visit_custom_media_query(&mut **self, node)
+    fn fold_delimiter_value(
+        &mut self,
+        node: DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) -> DelimiterValue {
+        <V as FoldAstPath>::fold_delimiter_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_media_query_media_type(&mut self, node: &CustomMediaQueryMediaType) {
-        <V as VisitAll>::visit_custom_media_query_media_type(&mut **self, node)
+    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
+        <V as FoldAstPath>::fold_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
-        <V as VisitAll>::visit_custom_property_name(&mut **self, node)
+    fn fold_dimension_token(
+        &mut self,
+        node: DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) -> DimensionToken {
+        <V as FoldAstPath>::fold_dimension_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_dashed_ident(&mut self, node: &DashedIdent) {
-        <V as VisitAll>::visit_dashed_ident(&mut **self, node)
+    fn fold_document_prelude(
+        &mut self,
+        node: DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPrelude {
+        <V as FoldAstPath>::fold_document_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_declaration(&mut self, node: &Declaration) {
-        <V as VisitAll>::visit_declaration(&mut **self, node)
+    fn fold_document_prelude_matching_function(
+        &mut self,
+        node: DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPreludeMatchingFunction {
+        <V as FoldAstPath>::fold_document_prelude_matching_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_declaration_name(&mut self, node: &DeclarationName) {
-        <V as VisitAll>::visit_declaration_name(&mut **self, node)
+    fn fold_document_prelude_matching_functions(
+        &mut self,
+        node: Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<DocumentPreludeMatchingFunction> {
+        <V as FoldAstPath>::fold_document_prelude_matching_functions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
-        <V as VisitAll>::visit_declaration_or_at_rule(&mut **self, node)
+    fn fold_extension_name(
+        &mut self,
+        node: ExtensionName,
+        __ast_path: &mut AstKindPath,
+    ) -> ExtensionName {
+        <V as FoldAstPath>::fold_extension_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_delimiter(&mut self, node: &Delimiter) {
-        <V as VisitAll>::visit_delimiter(&mut **self, node)
+    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
+        <V as FoldAstPath>::fold_family_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
-        <V as VisitAll>::visit_delimiter_value(&mut **self, node)
+    fn fold_family_names(
+        &mut self,
+        node: Vec<FamilyName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<FamilyName> {
+        <V as FoldAstPath>::fold_family_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_dimension(&mut self, node: &Dimension) {
-        <V as VisitAll>::visit_dimension(&mut **self, node)
+    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
+        <V as FoldAstPath>::fold_flex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_dimension_token(&mut self, node: &DimensionToken) {
-        <V as VisitAll>::visit_dimension_token(&mut **self, node)
+    fn fold_font_feature_values_prelude(
+        &mut self,
+        node: FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> FontFeatureValuesPrelude {
+        <V as FoldAstPath>::fold_font_feature_values_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
-        <V as VisitAll>::visit_document_prelude(&mut **self, node)
+    fn fold_forgiving_complex_selector(
+        &mut self,
+        node: ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingComplexSelector {
+        <V as FoldAstPath>::fold_forgiving_complex_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_document_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
-        <V as VisitAll>::visit_document_prelude_matching_function(&mut **self, node)
+    fn fold_forgiving_complex_selectors(
+        &mut self,
+        node: Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingComplexSelector> {
+        <V as FoldAstPath>::fold_forgiving_complex_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_document_prelude_matching_functions(
+    fn fold_forgiving_relative_selector(
         &mut self,
-        node: &[DocumentPreludeMatchingFunction],
-    ) {
-        <V as VisitAll>::visit_document_prelude_matching_functions(&mut **self, node)
+        node: ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelector {
+        <V as FoldAstPath>::fold_forgiving_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_extension_name(&mut self, node: &ExtensionName) {
-        <V as VisitAll>::visit_extension_name(&mut **self, node)
+    fn fold_forgiving_relative_selector_list(
+        &mut self,
+        node: ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelectorList {
+        <V as FoldAstPath>::fold_forgiving_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_family_name(&mut self, node: &FamilyName) {
-        <V as VisitAll>::visit_family_name(&mut **self, node)
+    fn fold_forgiving_relative_selectors(
+        &mut self,
+        node: Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingRelativeSelector> {
+        <V as FoldAstPath>::fold_forgiving_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_family_names(&mut self, node: &[FamilyName]) {
-        <V as VisitAll>::visit_family_names(&mut **self, node)
+    fn fold_forgiving_selector_list(
+        &mut self,
+        node: ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingSelectorList {
+        <V as FoldAstPath>::fold_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_flex(&mut self, node: &Flex) {
-        <V as VisitAll>::visit_flex(&mut **self, node)
+    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
+        <V as FoldAstPath>::fold_frequency(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
-        <V as VisitAll>::visit_font_feature_values_prelude(&mut **self, node)
+    fn fold_frequency_percentage(
+        &mut self,
+        node: FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> FrequencyPercentage {
+        <V as FoldAstPath>::fold_frequency_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
-        <V as VisitAll>::visit_forgiving_complex_selector(&mut **self, node)
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
-        <V as VisitAll>::visit_forgiving_complex_selectors(&mut **self, node)
+    fn fold_function_name(
+        &mut self,
+        node: FunctionName,
+        __ast_path: &mut AstKindPath,
+    ) -> FunctionName {
+        <V as FoldAstPath>::fold_function_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
-        <V as VisitAll>::visit_forgiving_relative_selector(&mut **self, node)
+    fn fold_general_enclosed(
+        &mut self,
+        node: GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) -> GeneralEnclosed {
+        <V as FoldAstPath>::fold_general_enclosed(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
-        <V as VisitAll>::visit_forgiving_relative_selector_list(&mut **self, node)
+    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
+        <V as FoldAstPath>::fold_hex_color(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
-        <V as VisitAll>::visit_forgiving_relative_selectors(&mut **self, node)
+    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
+        <V as FoldAstPath>::fold_hue(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
-        <V as VisitAll>::visit_forgiving_selector_list(&mut **self, node)
+    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
+        <V as FoldAstPath>::fold_id_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_frequency(&mut self, node: &Frequency) {
-        <V as VisitAll>::visit_frequency(&mut **self, node)
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
-        <V as VisitAll>::visit_frequency_percentage(&mut **self, node)
+    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
+        <V as FoldAstPath>::fold_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <V as VisitAll>::visit_function(&mut **self, node)
+    fn fold_import_conditions(
+        &mut self,
+        node: ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportConditions {
+        <V as FoldAstPath>::fold_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_function_name(&mut self, node: &FunctionName) {
-        <V as VisitAll>::visit_function_name(&mut **self, node)
+    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
+        <V as FoldAstPath>::fold_import_href(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
-        <V as VisitAll>::visit_general_enclosed(&mut **self, node)
+    fn fold_import_layer_name(
+        &mut self,
+        node: ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportLayerName {
+        <V as FoldAstPath>::fold_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_hex_color(&mut self, node: &HexColor) {
-        <V as VisitAll>::visit_hex_color(&mut **self, node)
+    fn fold_import_prelude(
+        &mut self,
+        node: ImportPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPrelude {
+        <V as FoldAstPath>::fold_import_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_hue(&mut self, node: &Hue) {
-        <V as VisitAll>::visit_hue(&mut **self, node)
+    fn fold_important_flag(
+        &mut self,
+        node: ImportantFlag,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportantFlag {
+        <V as FoldAstPath>::fold_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_id_selector(&mut self, node: &IdSelector) {
-        <V as VisitAll>::visit_id_selector(&mut **self, node)
+    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
+        <V as FoldAstPath>::fold_integer(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <V as VisitAll>::visit_ident(&mut **self, node)
+    fn fold_keyframe_block(
+        &mut self,
+        node: KeyframeBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeBlock {
+        <V as FoldAstPath>::fold_keyframe_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_idents(&mut self, node: &[Ident]) {
-        <V as VisitAll>::visit_idents(&mut **self, node)
+    fn fold_keyframe_selector(
+        &mut self,
+        node: KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeSelector {
+        <V as FoldAstPath>::fold_keyframe_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_conditions(&mut self, node: &ImportConditions) {
-        <V as VisitAll>::visit_import_conditions(&mut **self, node)
+    fn fold_keyframe_selectors(
+        &mut self,
+        node: Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<KeyframeSelector> {
+        <V as FoldAstPath>::fold_keyframe_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_href(&mut self, node: &ImportHref) {
-        <V as VisitAll>::visit_import_href(&mut **self, node)
+    fn fold_keyframes_name(
+        &mut self,
+        node: KeyframesName,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesName {
+        <V as FoldAstPath>::fold_keyframes_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
-        <V as VisitAll>::visit_import_layer_name(&mut **self, node)
+    fn fold_keyframes_pseudo_function(
+        &mut self,
+        node: KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoFunction {
+        <V as FoldAstPath>::fold_keyframes_pseudo_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_prelude(&mut self, node: &ImportPrelude) {
-        <V as VisitAll>::visit_import_prelude(&mut **self, node)
+    fn fold_keyframes_pseudo_prefix(
+        &mut self,
+        node: KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoPrefix {
+        <V as FoldAstPath>::fold_keyframes_pseudo_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_important_flag(&mut self, node: &ImportantFlag) {
-        <V as VisitAll>::visit_important_flag(&mut **self, node)
+    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
+        <V as FoldAstPath>::fold_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_integer(&mut self, node: &Integer) {
-        <V as VisitAll>::visit_integer(&mut **self, node)
+    fn fold_layer_name_list(
+        &mut self,
+        node: LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerNameList {
+        <V as FoldAstPath>::fold_layer_name_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
-        <V as VisitAll>::visit_keyframe_block(&mut **self, node)
+    fn fold_layer_names(
+        &mut self,
+        node: Vec<LayerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<LayerName> {
+        <V as FoldAstPath>::fold_layer_names(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
-        <V as VisitAll>::visit_keyframe_selector(&mut **self, node)
+    fn fold_layer_prelude(
+        &mut self,
+        node: LayerPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerPrelude {
+        <V as FoldAstPath>::fold_layer_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
-        <V as VisitAll>::visit_keyframe_selectors(&mut **self, node)
+    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
+        <V as FoldAstPath>::fold_length(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframes_name(&mut self, node: &KeyframesName) {
-        <V as VisitAll>::visit_keyframes_name(&mut **self, node)
+    fn fold_length_percentage(
+        &mut self,
+        node: LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> LengthPercentage {
+        <V as FoldAstPath>::fold_length_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
-        <V as VisitAll>::visit_keyframes_pseudo_function(&mut **self, node)
+    fn fold_list_of_component_values(
+        &mut self,
+        node: ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) -> ListOfComponentValues {
+        <V as FoldAstPath>::fold_list_of_component_values(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
-        <V as VisitAll>::visit_keyframes_pseudo_prefix(&mut **self, node)
+    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
+        <V as FoldAstPath>::fold_media_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_name(&mut self, node: &LayerName) {
-        <V as VisitAll>::visit_layer_name(&mut **self, node)
+    fn fold_media_condition(
+        &mut self,
+        node: MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaCondition {
+        <V as FoldAstPath>::fold_media_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_name_list(&mut self, node: &LayerNameList) {
-        <V as VisitAll>::visit_layer_name_list(&mut **self, node)
+    fn fold_media_condition_all_type(
+        &mut self,
+        node: MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionAllType {
+        <V as FoldAstPath>::fold_media_condition_all_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_names(&mut self, node: &[LayerName]) {
-        <V as VisitAll>::visit_layer_names(&mut **self, node)
+    fn fold_media_condition_all_types(
+        &mut self,
+        node: Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionAllType> {
+        <V as FoldAstPath>::fold_media_condition_all_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
-        <V as VisitAll>::visit_layer_prelude(&mut **self, node)
+    fn fold_media_condition_type(
+        &mut self,
+        node: MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionType {
+        <V as FoldAstPath>::fold_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_length(&mut self, node: &Length) {
-        <V as VisitAll>::visit_length(&mut **self, node)
+    fn fold_media_condition_without_or(
+        &mut self,
+        node: MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOr {
+        <V as FoldAstPath>::fold_media_condition_without_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_length_percentage(&mut self, node: &LengthPercentage) {
-        <V as VisitAll>::visit_length_percentage(&mut **self, node)
+    fn fold_media_condition_without_or_type(
+        &mut self,
+        node: MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOrType {
+        <V as FoldAstPath>::fold_media_condition_without_or_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
-        <V as VisitAll>::visit_list_of_component_values(&mut **self, node)
+    fn fold_media_condition_without_or_types(
+        &mut self,
+        node: Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionWithoutOrType> {
+        <V as FoldAstPath>::fold_media_condition_without_or_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_and(&mut self, node: &MediaAnd) {
-        <V as VisitAll>::visit_media_and(&mut **self, node)
+    fn fold_media_feature(
+        &mut self,
+        node: MediaFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeature {
+        <V as FoldAstPath>::fold_media_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition(&mut self, node: &MediaCondition) {
-        <V as VisitAll>::visit_media_condition(&mut **self, node)
+    fn fold_media_feature_boolean(
+        &mut self,
+        node: MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureBoolean {
+        <V as FoldAstPath>::fold_media_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
-        <V as VisitAll>::visit_media_condition_all_type(&mut **self, node)
+    fn fold_media_feature_name(
+        &mut self,
+        node: MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureName {
+        <V as FoldAstPath>::fold_media_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
-        <V as VisitAll>::visit_media_condition_all_types(&mut **self, node)
+    fn fold_media_feature_plain(
+        &mut self,
+        node: MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeaturePlain {
+        <V as FoldAstPath>::fold_media_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
-        <V as VisitAll>::visit_media_condition_type(&mut **self, node)
+    fn fold_media_feature_range(
+        &mut self,
+        node: MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRange {
+        <V as FoldAstPath>::fold_media_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
-        <V as VisitAll>::visit_media_condition_without_or(&mut **self, node)
+    fn fold_media_feature_range_comparison(
+        &mut self,
+        node: MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeComparison {
+        <V as FoldAstPath>::fold_media_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_without_or_type(&mut self, node: &MediaConditionWithoutOrType) {
-        <V as VisitAll>::visit_media_condition_without_or_type(&mut **self, node)
+    fn fold_media_feature_range_interval(
+        &mut self,
+        node: MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeInterval {
+        <V as FoldAstPath>::fold_media_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_condition_without_or_types(&mut self, node: &[MediaConditionWithoutOrType]) {
-        <V as VisitAll>::visit_media_condition_without_or_types(&mut **self, node)
+    fn fold_media_feature_value(
+        &mut self,
+        node: MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureValue {
+        <V as FoldAstPath>::fold_media_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature(&mut self, node: &MediaFeature) {
-        <V as VisitAll>::visit_media_feature(&mut **self, node)
+    fn fold_media_in_parens(
+        &mut self,
+        node: MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaInParens {
+        <V as FoldAstPath>::fold_media_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
-        <V as VisitAll>::visit_media_feature_boolean(&mut **self, node)
+    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
+        <V as FoldAstPath>::fold_media_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
-        <V as VisitAll>::visit_media_feature_name(&mut **self, node)
+    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
+        <V as FoldAstPath>::fold_media_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
-        <V as VisitAll>::visit_media_feature_plain(&mut **self, node)
+    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
+        <V as FoldAstPath>::fold_media_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
-        <V as VisitAll>::visit_media_feature_range(&mut **self, node)
+    fn fold_media_query_list(
+        &mut self,
+        node: MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaQueryList {
+        <V as FoldAstPath>::fold_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
-        <V as VisitAll>::visit_media_feature_range_comparison(&mut **self, node)
+    fn fold_media_querys(
+        &mut self,
+        node: Vec<MediaQuery>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaQuery> {
+        <V as FoldAstPath>::fold_media_querys(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
-        <V as VisitAll>::visit_media_feature_range_interval(&mut **self, node)
+    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
+        <V as FoldAstPath>::fold_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
-        <V as VisitAll>::visit_media_feature_value(&mut **self, node)
+    fn fold_named_namespace(
+        &mut self,
+        node: NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedNamespace {
+        <V as FoldAstPath>::fold_named_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_in_parens(&mut self, node: &MediaInParens) {
-        <V as VisitAll>::visit_media_in_parens(&mut **self, node)
+    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
+        <V as FoldAstPath>::fold_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_not(&mut self, node: &MediaNot) {
-        <V as VisitAll>::visit_media_not(&mut **self, node)
+    fn fold_namespace_prefix(
+        &mut self,
+        node: NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrefix {
+        <V as FoldAstPath>::fold_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_or(&mut self, node: &MediaOr) {
-        <V as VisitAll>::visit_media_or(&mut **self, node)
+    fn fold_namespace_prelude(
+        &mut self,
+        node: NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrelude {
+        <V as FoldAstPath>::fold_namespace_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_query(&mut self, node: &MediaQuery) {
-        <V as VisitAll>::visit_media_query(&mut **self, node)
+    fn fold_namespace_prelude_uri(
+        &mut self,
+        node: NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePreludeUri {
+        <V as FoldAstPath>::fold_namespace_prelude_uri(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_query_list(&mut self, node: &MediaQueryList) {
-        <V as VisitAll>::visit_media_query_list(&mut **self, node)
+    fn fold_nesting_selector(
+        &mut self,
+        node: NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> NestingSelector {
+        <V as FoldAstPath>::fold_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_querys(&mut self, node: &[MediaQuery]) {
-        <V as VisitAll>::visit_media_querys(&mut **self, node)
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_media_type(&mut self, node: &MediaType) {
-        <V as VisitAll>::visit_media_type(&mut **self, node)
+    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
+        <V as FoldAstPath>::fold_number_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_named_namespace(&mut self, node: &NamedNamespace) {
-        <V as VisitAll>::visit_named_namespace(&mut **self, node)
+    fn fold_opt_at_rule_prelude(
+        &mut self,
+        node: Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<AtRulePrelude>> {
+        <V as FoldAstPath>::fold_opt_at_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut **self, node)
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
+        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
-        <V as VisitAll>::visit_namespace_prefix(&mut **self, node)
+    fn fold_opt_attribute_selector_matcher(
+        &mut self,
+        node: Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorMatcher> {
+        <V as FoldAstPath>::fold_opt_attribute_selector_matcher(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
-        <V as VisitAll>::visit_namespace_prelude(&mut **self, node)
+    fn fold_opt_attribute_selector_modifier(
+        &mut self,
+        node: Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorModifier> {
+        <V as FoldAstPath>::fold_opt_attribute_selector_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
-        <V as VisitAll>::visit_namespace_prelude_uri(&mut **self, node)
+    fn fold_opt_attribute_selector_value(
+        &mut self,
+        node: Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorValue> {
+        <V as FoldAstPath>::fold_opt_attribute_selector_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_nesting_selector(&mut self, node: &NestingSelector) {
-        <V as VisitAll>::visit_nesting_selector(&mut **self, node)
+    fn fold_opt_combinator(
+        &mut self,
+        node: Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Combinator> {
+        <V as FoldAstPath>::fold_opt_combinator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <V as VisitAll>::visit_number(&mut **self, node)
+    fn fold_opt_container_name(
+        &mut self,
+        node: Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ContainerName> {
+        <V as FoldAstPath>::fold_opt_container_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_number_type(&mut self, node: &NumberType) {
-        <V as VisitAll>::visit_number_type(&mut **self, node)
+    fn fold_opt_forgiving_selector_list(
+        &mut self,
+        node: Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ForgivingSelectorList> {
+        <V as FoldAstPath>::fold_opt_forgiving_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>) {
-        <V as VisitAll>::visit_opt_at_rule_prelude(&mut **self, node)
+    fn fold_opt_function(
+        &mut self,
+        node: Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Function>> {
+        <V as FoldAstPath>::fold_opt_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
+        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_matcher(&mut self, node: &Option<AttributeSelectorMatcher>) {
-        <V as VisitAll>::visit_opt_attribute_selector_matcher(&mut **self, node)
+    fn fold_opt_import_conditions(
+        &mut self,
+        node: Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportConditions>> {
+        <V as FoldAstPath>::fold_opt_import_conditions(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_modifier(&mut self, node: &Option<AttributeSelectorModifier>) {
-        <V as VisitAll>::visit_opt_attribute_selector_modifier(&mut **self, node)
+    fn fold_opt_import_layer_name(
+        &mut self,
+        node: Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportLayerName>> {
+        <V as FoldAstPath>::fold_opt_import_layer_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_value(&mut self, node: &Option<AttributeSelectorValue>) {
-        <V as VisitAll>::visit_opt_attribute_selector_value(&mut **self, node)
+    fn fold_opt_important_flag(
+        &mut self,
+        node: Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ImportantFlag> {
+        <V as FoldAstPath>::fold_opt_important_flag(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
-        <V as VisitAll>::visit_opt_combinator(&mut **self, node)
+    fn fold_opt_media_condition_type(
+        &mut self,
+        node: Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaConditionType>> {
+        <V as FoldAstPath>::fold_opt_media_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_container_name(&mut self, node: &Option<ContainerName>) {
-        <V as VisitAll>::visit_opt_container_name(&mut **self, node)
+    fn fold_opt_media_query_list(
+        &mut self,
+        node: Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaQueryList>> {
+        <V as FoldAstPath>::fold_opt_media_query_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_forgiving_selector_list(&mut self, node: &Option<ForgivingSelectorList>) {
-        <V as VisitAll>::visit_opt_forgiving_selector_list(&mut **self, node)
+    fn fold_opt_media_type(
+        &mut self,
+        node: Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<MediaType> {
+        <V as FoldAstPath>::fold_opt_media_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_function(&mut self, node: &Option<Box<Function>>) {
-        <V as VisitAll>::visit_opt_function(&mut **self, node)
+    fn fold_opt_namespace(
+        &mut self,
+        node: Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Namespace> {
+        <V as FoldAstPath>::fold_opt_namespace(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <V as VisitAll>::visit_opt_ident(&mut **self, node)
+    fn fold_opt_namespace_prefix(
+        &mut self,
+        node: Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NamespacePrefix> {
+        <V as FoldAstPath>::fold_opt_namespace_prefix(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>) {
-        <V as VisitAll>::visit_opt_import_conditions(&mut **self, node)
+    fn fold_opt_nesting_selector(
+        &mut self,
+        node: Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NestingSelector> {
+        <V as FoldAstPath>::fold_opt_nesting_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>) {
-        <V as VisitAll>::visit_opt_import_layer_name(&mut **self, node)
+    fn fold_opt_number(
+        &mut self,
+        node: Option<Number>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Number> {
+        <V as FoldAstPath>::fold_opt_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>) {
-        <V as VisitAll>::visit_opt_important_flag(&mut **self, node)
+    fn fold_opt_page_selector_pseudos(
+        &mut self,
+        node: Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PageSelectorPseudo>> {
+        <V as FoldAstPath>::fold_opt_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_media_condition_type(&mut self, node: &Option<Box<MediaConditionType>>) {
-        <V as VisitAll>::visit_opt_media_condition_type(&mut **self, node)
+    fn fold_opt_page_selector_type(
+        &mut self,
+        node: Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<PageSelectorType> {
+        <V as FoldAstPath>::fold_opt_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>) {
-        <V as VisitAll>::visit_opt_media_query_list(&mut **self, node)
+    fn fold_opt_pseudo_class_selector_childrens(
+        &mut self,
+        node: Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoClassSelectorChildren>> {
+        <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_media_type(&mut self, node: &Option<MediaType>) {
-        <V as VisitAll>::visit_opt_media_type(&mut **self, node)
+    fn fold_opt_pseudo_element_selector_childrens(
+        &mut self,
+        node: Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoElementSelectorChildren>> {
+        <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut **self, node)
+    fn fold_opt_simple_block(
+        &mut self,
+        node: Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<SimpleBlock> {
+        <V as FoldAstPath>::fold_opt_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_namespace_prefix(&mut self, node: &Option<NamespacePrefix>) {
-        <V as VisitAll>::visit_opt_namespace_prefix(&mut **self, node)
+    fn fold_opt_type_selector(
+        &mut self,
+        node: Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TypeSelector>> {
+        <V as FoldAstPath>::fold_opt_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_nesting_selector(&mut self, node: &Option<NestingSelector>) {
-        <V as VisitAll>::visit_opt_nesting_selector(&mut **self, node)
+    fn fold_opt_url_modifiers(
+        &mut self,
+        node: Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<UrlModifier>> {
+        <V as FoldAstPath>::fold_opt_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_number(&mut self, node: &Option<Number>) {
-        <V as VisitAll>::visit_opt_number(&mut **self, node)
+    fn fold_opt_url_value(
+        &mut self,
+        node: Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<UrlValue>> {
+        <V as FoldAstPath>::fold_opt_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_page_selector_pseudos(&mut self, node: &Option<Vec<PageSelectorPseudo>>) {
-        <V as VisitAll>::visit_opt_page_selector_pseudos(&mut **self, node)
+    fn fold_page_selector(
+        &mut self,
+        node: PageSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelector {
+        <V as FoldAstPath>::fold_page_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_page_selector_type(&mut self, node: &Option<PageSelectorType>) {
-        <V as VisitAll>::visit_opt_page_selector_type(&mut **self, node)
+    fn fold_page_selector_list(
+        &mut self,
+        node: PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorList {
+        <V as FoldAstPath>::fold_page_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_pseudo_class_selector_childrens(
+    fn fold_page_selector_pseudo(
         &mut self,
-        node: &Option<Vec<PseudoClassSelectorChildren>>,
-    ) {
-        <V as VisitAll>::visit_opt_pseudo_class_selector_childrens(&mut **self, node)
+        node: PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorPseudo {
+        <V as FoldAstPath>::fold_page_selector_pseudo(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_pseudo_element_selector_childrens(
+    fn fold_page_selector_pseudos(
         &mut self,
-        node: &Option<Vec<PseudoElementSelectorChildren>>,
-    ) {
-        <V as VisitAll>::visit_opt_pseudo_element_selector_childrens(&mut **self, node)
+        node: Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelectorPseudo> {
+        <V as FoldAstPath>::fold_page_selector_pseudos(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>) {
-        <V as VisitAll>::visit_opt_simple_block(&mut **self, node)
+    fn fold_page_selector_type(
+        &mut self,
+        node: PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorType {
+        <V as FoldAstPath>::fold_page_selector_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>) {
-        <V as VisitAll>::visit_opt_type_selector(&mut **self, node)
+    fn fold_page_selectors(
+        &mut self,
+        node: Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelector> {
+        <V as FoldAstPath>::fold_page_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>) {
-        <V as VisitAll>::visit_opt_url_modifiers(&mut **self, node)
+    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
+        <V as FoldAstPath>::fold_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_url_value(&mut self, node: &Option<Box<UrlValue>>) {
-        <V as VisitAll>::visit_opt_url_value(&mut **self, node)
+    fn fold_pseudo_class_selector(
+        &mut self,
+        node: PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelector {
+        <V as FoldAstPath>::fold_pseudo_class_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector(&mut self, node: &PageSelector) {
-        <V as VisitAll>::visit_page_selector(&mut **self, node)
+    fn fold_pseudo_class_selector_children(
+        &mut self,
+        node: PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelectorChildren {
+        <V as FoldAstPath>::fold_pseudo_class_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
-        <V as VisitAll>::visit_page_selector_list(&mut **self, node)
+    fn fold_pseudo_class_selector_childrens(
+        &mut self,
+        node: Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoClassSelectorChildren> {
+        <V as FoldAstPath>::fold_pseudo_class_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
-        <V as VisitAll>::visit_page_selector_pseudo(&mut **self, node)
+    fn fold_pseudo_element_selector(
+        &mut self,
+        node: PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelector {
+        <V as FoldAstPath>::fold_pseudo_element_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
-        <V as VisitAll>::visit_page_selector_pseudos(&mut **self, node)
+    fn fold_pseudo_element_selector_children(
+        &mut self,
+        node: PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelectorChildren {
+        <V as FoldAstPath>::fold_pseudo_element_selector_children(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
-        <V as VisitAll>::visit_page_selector_type(&mut **self, node)
+    fn fold_pseudo_element_selector_childrens(
+        &mut self,
+        node: Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoElementSelectorChildren> {
+        <V as FoldAstPath>::fold_pseudo_element_selector_childrens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_page_selectors(&mut self, node: &[PageSelector]) {
-        <V as VisitAll>::visit_page_selectors(&mut **self, node)
+    fn fold_qualified_rule(
+        &mut self,
+        node: QualifiedRule,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRule {
+        <V as FoldAstPath>::fold_qualified_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_percentage(&mut self, node: &Percentage) {
-        <V as VisitAll>::visit_percentage(&mut **self, node)
+    fn fold_qualified_rule_prelude(
+        &mut self,
+        node: QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRulePrelude {
+        <V as FoldAstPath>::fold_qualified_rule_prelude(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
-        <V as VisitAll>::visit_pseudo_class_selector(&mut **self, node)
+    fn fold_query_in_parens(
+        &mut self,
+        node: QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> QueryInParens {
+        <V as FoldAstPath>::fold_query_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
-        <V as VisitAll>::visit_pseudo_class_selector_children(&mut **self, node)
+    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
+        <V as FoldAstPath>::fold_ratio(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
-        <V as VisitAll>::visit_pseudo_class_selector_childrens(&mut **self, node)
+    fn fold_relative_selector(
+        &mut self,
+        node: RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelector {
+        <V as FoldAstPath>::fold_relative_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
-        <V as VisitAll>::visit_pseudo_element_selector(&mut **self, node)
+    fn fold_relative_selector_list(
+        &mut self,
+        node: RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelectorList {
+        <V as FoldAstPath>::fold_relative_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
-        <V as VisitAll>::visit_pseudo_element_selector_children(&mut **self, node)
+    fn fold_relative_selectors(
+        &mut self,
+        node: Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<RelativeSelector> {
+        <V as FoldAstPath>::fold_relative_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
-        <V as VisitAll>::visit_pseudo_element_selector_childrens(&mut **self, node)
+    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
+        <V as FoldAstPath>::fold_resolution(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
-        <V as VisitAll>::visit_qualified_rule(&mut **self, node)
+    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
+        <V as FoldAstPath>::fold_rule(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
-        <V as VisitAll>::visit_qualified_rule_prelude(&mut **self, node)
+    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
+        <V as FoldAstPath>::fold_rules(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_query_in_parens(&mut self, node: &QueryInParens) {
-        <V as VisitAll>::visit_query_in_parens(&mut **self, node)
+    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
+        <V as FoldAstPath>::fold_scope_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ratio(&mut self, node: &Ratio) {
-        <V as VisitAll>::visit_ratio(&mut **self, node)
+    fn fold_selector_list(
+        &mut self,
+        node: SelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> SelectorList {
+        <V as FoldAstPath>::fold_selector_list(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_relative_selector(&mut self, node: &RelativeSelector) {
-        <V as VisitAll>::visit_relative_selector(&mut **self, node)
+    fn fold_sequence_of_custom_idents(
+        &mut self,
+        node: SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) -> SequenceOfCustomIdents {
+        <V as FoldAstPath>::fold_sequence_of_custom_idents(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
-        <V as VisitAll>::visit_relative_selector_list(&mut **self, node)
+    fn fold_simple_block(
+        &mut self,
+        node: SimpleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleBlock {
+        <V as FoldAstPath>::fold_simple_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
-        <V as VisitAll>::visit_relative_selectors(&mut **self, node)
+    fn fold_size_feature(
+        &mut self,
+        node: SizeFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeature {
+        <V as FoldAstPath>::fold_size_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_resolution(&mut self, node: &Resolution) {
-        <V as VisitAll>::visit_resolution(&mut **self, node)
+    fn fold_size_feature_boolean(
+        &mut self,
+        node: SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureBoolean {
+        <V as FoldAstPath>::fold_size_feature_boolean(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_rule(&mut self, node: &Rule) {
-        <V as VisitAll>::visit_rule(&mut **self, node)
+    fn fold_size_feature_name(
+        &mut self,
+        node: SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureName {
+        <V as FoldAstPath>::fold_size_feature_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_rules(&mut self, node: &[Rule]) {
-        <V as VisitAll>::visit_rules(&mut **self, node)
+    fn fold_size_feature_plain(
+        &mut self,
+        node: SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeaturePlain {
+        <V as FoldAstPath>::fold_size_feature_plain(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_scope_range(&mut self, node: &ScopeRange) {
-        <V as VisitAll>::visit_scope_range(&mut **self, node)
+    fn fold_size_feature_range(
+        &mut self,
+        node: SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRange {
+        <V as FoldAstPath>::fold_size_feature_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_selector_list(&mut self, node: &SelectorList) {
-        <V as VisitAll>::visit_selector_list(&mut **self, node)
+    fn fold_size_feature_range_comparison(
+        &mut self,
+        node: SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeComparison {
+        <V as FoldAstPath>::fold_size_feature_range_comparison(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
-        <V as VisitAll>::visit_sequence_of_custom_idents(&mut **self, node)
+    fn fold_size_feature_range_interval(
+        &mut self,
+        node: SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeInterval {
+        <V as FoldAstPath>::fold_size_feature_range_interval(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_simple_block(&mut self, node: &SimpleBlock) {
-        <V as VisitAll>::visit_simple_block(&mut **self, node)
+    fn fold_size_feature_value(
+        &mut self,
+        node: SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureValue {
+        <V as FoldAstPath>::fold_size_feature_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature(&mut self, node: &SizeFeature) {
-        <V as VisitAll>::visit_size_feature(&mut **self, node)
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
+        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
-        <V as VisitAll>::visit_size_feature_boolean(&mut **self, node)
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
-        <V as VisitAll>::visit_size_feature_name(&mut **self, node)
+    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
+        <V as FoldAstPath>::fold_style_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
-        <V as VisitAll>::visit_size_feature_plain(&mut **self, node)
+    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
+        <V as FoldAstPath>::fold_stylesheet(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
-        <V as VisitAll>::visit_size_feature_range(&mut **self, node)
+    fn fold_subclass_selector(
+        &mut self,
+        node: SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> SubclassSelector {
+        <V as FoldAstPath>::fold_subclass_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
-        <V as VisitAll>::visit_size_feature_range_comparison(&mut **self, node)
+    fn fold_subclass_selectors(
+        &mut self,
+        node: Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SubclassSelector> {
+        <V as FoldAstPath>::fold_subclass_selectors(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
-        <V as VisitAll>::visit_size_feature_range_interval(&mut **self, node)
+    fn fold_supports_and(
+        &mut self,
+        node: SupportsAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsAnd {
+        <V as FoldAstPath>::fold_supports_and(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
-        <V as VisitAll>::visit_size_feature_value(&mut **self, node)
+    fn fold_supports_condition(
+        &mut self,
+        node: SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsCondition {
+        <V as FoldAstPath>::fold_supports_condition(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
+    fn fold_supports_condition_type(
+        &mut self,
+        node: SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsConditionType {
+        <V as FoldAstPath>::fold_supports_condition_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <V as VisitAll>::visit_str(&mut **self, node)
+    fn fold_supports_condition_types(
+        &mut self,
+        node: Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SupportsConditionType> {
+        <V as FoldAstPath>::fold_supports_condition_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_style_block(&mut self, node: &StyleBlock) {
-        <V as VisitAll>::visit_style_block(&mut **self, node)
+    fn fold_supports_feature(
+        &mut self,
+        node: SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsFeature {
+        <V as FoldAstPath>::fold_supports_feature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_stylesheet(&mut self, node: &Stylesheet) {
-        <V as VisitAll>::visit_stylesheet(&mut **self, node)
+    fn fold_supports_in_parens(
+        &mut self,
+        node: SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsInParens {
+        <V as FoldAstPath>::fold_supports_in_parens(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
-        <V as VisitAll>::visit_subclass_selector(&mut **self, node)
+    fn fold_supports_not(
+        &mut self,
+        node: SupportsNot,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsNot {
+        <V as FoldAstPath>::fold_supports_not(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
-        <V as VisitAll>::visit_subclass_selectors(&mut **self, node)
+    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
+        <V as FoldAstPath>::fold_supports_or(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_and(&mut self, node: &SupportsAnd) {
-        <V as VisitAll>::visit_supports_and(&mut **self, node)
+    fn fold_tag_name_selector(
+        &mut self,
+        node: TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TagNameSelector {
+        <V as FoldAstPath>::fold_tag_name_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_condition(&mut self, node: &SupportsCondition) {
-        <V as VisitAll>::visit_supports_condition(&mut **self, node)
+    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
+        <V as FoldAstPath>::fold_time(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
-        <V as VisitAll>::visit_supports_condition_type(&mut **self, node)
+    fn fold_time_percentage(
+        &mut self,
+        node: TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> TimePercentage {
+        <V as FoldAstPath>::fold_time_percentage(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
-        <V as VisitAll>::visit_supports_condition_types(&mut **self, node)
+    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
+        <V as FoldAstPath>::fold_token(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_feature(&mut self, node: &SupportsFeature) {
-        <V as VisitAll>::visit_supports_feature(&mut **self, node)
+    fn fold_token_and_span(
+        &mut self,
+        node: TokenAndSpan,
+        __ast_path: &mut AstKindPath,
+    ) -> TokenAndSpan {
+        <V as FoldAstPath>::fold_token_and_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
-        <V as VisitAll>::visit_supports_in_parens(&mut **self, node)
+    fn fold_type_selector(
+        &mut self,
+        node: TypeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TypeSelector {
+        <V as FoldAstPath>::fold_type_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_not(&mut self, node: &SupportsNot) {
-        <V as VisitAll>::visit_supports_not(&mut **self, node)
+    fn fold_unicode_range(
+        &mut self,
+        node: UnicodeRange,
+        __ast_path: &mut AstKindPath,
+    ) -> UnicodeRange {
+        <V as FoldAstPath>::fold_unicode_range(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_supports_or(&mut self, node: &SupportsOr) {
-        <V as VisitAll>::visit_supports_or(&mut **self, node)
+    fn fold_universal_selector(
+        &mut self,
+        node: UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> UniversalSelector {
+        <V as FoldAstPath>::fold_universal_selector(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
-        <V as VisitAll>::visit_tag_name_selector(&mut **self, node)
+    fn fold_unknown_dimension(
+        &mut self,
+        node: UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) -> UnknownDimension {
+        <V as FoldAstPath>::fold_unknown_dimension(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_time(&mut self, node: &Time) {
-        <V as VisitAll>::visit_time(&mut **self, node)
+    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
+        <V as FoldAstPath>::fold_url(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_time_percentage(&mut self, node: &TimePercentage) {
-        <V as VisitAll>::visit_time_percentage(&mut **self, node)
+    fn fold_url_key_value(
+        &mut self,
+        node: UrlKeyValue,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlKeyValue {
+        <V as FoldAstPath>::fold_url_key_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut **self, node)
+    fn fold_url_modifier(
+        &mut self,
+        node: UrlModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlModifier {
+        <V as FoldAstPath>::fold_url_modifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut **self, node)
+    fn fold_url_modifiers(
+        &mut self,
+        node: Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<UrlModifier> {
+        <V as FoldAstPath>::fold_url_modifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_type_selector(&mut self, node: &TypeSelector) {
-        <V as VisitAll>::visit_type_selector(&mut **self, node)
+    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
+        <V as FoldAstPath>::fold_url_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_unicode_range(&mut self, node: &UnicodeRange) {
-        <V as VisitAll>::visit_unicode_range(&mut **self, node)
+    fn fold_url_value_raw(
+        &mut self,
+        node: UrlValueRaw,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlValueRaw {
+        <V as FoldAstPath>::fold_url_value_raw(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_universal_selector(&mut self, node: &UniversalSelector) {
-        <V as VisitAll>::visit_universal_selector(&mut **self, node)
+    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
+        <V as FoldAstPath>::fold_wq_name(&mut **self, node, __ast_path)
     }
-
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<A, B> FoldAstPath for ::swc_visit::Either<A, B>
+where
+    A: FoldAstPath,
+    B: FoldAstPath,
+{
     #[inline]
-    fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
-        <V as VisitAll>::visit_unknown_dimension(&mut **self, node)
+    fn fold_absolute_color_base(
+        &mut self,
+        node: AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) -> AbsoluteColorBase {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_absolute_color_base(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_absolute_color_base(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_url(&mut self, node: &Url) {
-        <V as VisitAll>::visit_url(&mut **self, node)
+    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_alpha_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_alpha_value(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
-        <V as VisitAll>::visit_url_key_value(&mut **self, node)
+    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_an_plus_b(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_an_plus_b(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_url_modifier(&mut self, node: &UrlModifier) {
-        <V as VisitAll>::visit_url_modifier(&mut **self, node)
+    fn fold_an_plus_b_notation(
+        &mut self,
+        node: AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) -> AnPlusBNotation {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_an_plus_b_notation(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_an_plus_b_notation(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
-        <V as VisitAll>::visit_url_modifiers(&mut **self, node)
+    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
+        match self {
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_angle(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_angle(visitor, node, __ast_path),
+        }
     }
 
     #[inline]
-    fn visit_url_value(&mut self, node: &UrlValue) {
-        <V as VisitAll>::visit_url_value(&mut **self, node)
+    fn fold_angle_percentage(
+        &mut self,
+        node: AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> AnglePercentage {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_angle_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_angle_percentage(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
-        <V as VisitAll>::visit_url_value_raw(&mut **self, node)
+    fn fold_any_namespace(
+        &mut self,
+        node: AnyNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> AnyNamespace {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_any_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_any_namespace(visitor, node, __ast_path)
+            }
+        }
     }
 
     #[inline]
-    fn visit_wq_name(&mut self, node: &WqName) {
-        <V as VisitAll>::visit_wq_name(&mut **self, node)
-    }
-}
-impl<A, B> VisitAll for ::swc_visit::Either<A, B>
-where
-    A: VisitAll,
-    B: VisitAll,
-{
-    #[inline]
-    fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
+    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_absolute_color_base(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_absolute_color_base(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_at_rule(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_at_rule(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_alpha_value(&mut self, node: &AlphaValue) {
+    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_alpha_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_alpha_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_at_rule_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_at_rule_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_an_plus_b(&mut self, node: &AnPlusB) {
+    fn fold_at_rule_prelude(
+        &mut self,
+        node: AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> AtRulePrelude {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_an_plus_b(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_an_plus_b(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_at_rule_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_at_rule_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_an_plus_b_notation(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_an_plus_b_notation(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_angle(&mut self, node: &Angle) {
+    fn fold_attribute_selector(
+        &mut self,
+        node: AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_angle(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_angle(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_attribute_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_attribute_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
+    fn fold_attribute_selector_matcher(
+        &mut self,
+        node: AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcher {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_angle_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_angle_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_attribute_selector_matcher(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_attribute_selector_matcher(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_any_namespace(&mut self, node: &AnyNamespace) {
+    fn fold_attribute_selector_matcher_value(
+        &mut self,
+        node: AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcherValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_any_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_any_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_attribute_selector_matcher_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_attribute_selector_matcher_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_at_rule(&mut self, node: &AtRule) {
+    fn fold_attribute_selector_modifier(
+        &mut self,
+        node: AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorModifier {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_at_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_at_rule(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_attribute_selector_modifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_attribute_selector_modifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_at_rule_name(&mut self, node: &AtRuleName) {
+    fn fold_attribute_selector_value(
+        &mut self,
+        node: AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_at_rule_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_at_rule_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_attribute_selector_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_attribute_selector_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
+    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_at_rule_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_at_rule_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_bin_op(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_bin_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
+    fn fold_calc_operator(
+        &mut self,
+        node: CalcOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperator {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_calc_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_calc_operator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
+    fn fold_calc_operator_type(
+        &mut self,
+        node: CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperatorType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attribute_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attribute_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_calc_operator_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_calc_operator_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
+    fn fold_calc_product(
+        &mut self,
+        node: CalcProduct,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProduct {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_attribute_selector_matcher(visitor, node)
+                FoldAstPath::fold_calc_product(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_attribute_selector_matcher(visitor, node)
+                FoldAstPath::fold_calc_product(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
+    fn fold_calc_product_or_operator(
+        &mut self,
+        node: CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProductOrOperator {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_attribute_selector_matcher_value(visitor, node)
+                FoldAstPath::fold_calc_product_or_operator(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_attribute_selector_matcher_value(visitor, node)
+                FoldAstPath::fold_calc_product_or_operator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
+    fn fold_calc_product_or_operators(
+        &mut self,
+        node: Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcProductOrOperator> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_attribute_selector_modifier(visitor, node)
+                FoldAstPath::fold_calc_product_or_operators(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_attribute_selector_modifier(visitor, node)
+                FoldAstPath::fold_calc_product_or_operators(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
+    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_attribute_selector_value(visitor, node)
+                FoldAstPath::fold_calc_sum(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_attribute_selector_value(visitor, node)
+                FoldAstPath::fold_calc_sum(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_bin_op(&mut self, node: &BinOp) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_bin_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_bin_op(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_calc_operator(&mut self, node: &CalcOperator) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_calc_operator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_calc_operator(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
+    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_calc_operator_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_calc_operator_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_calc_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_calc_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_calc_product(&mut self, node: &CalcProduct) {
+    fn fold_calc_value_or_operator(
+        &mut self,
+        node: CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcValueOrOperator {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_calc_product(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_calc_product(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_calc_value_or_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_calc_value_or_operator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
+    fn fold_calc_value_or_operators(
+        &mut self,
+        node: Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcValueOrOperator> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_calc_product_or_operator(visitor, node)
+                FoldAstPath::fold_calc_value_or_operators(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_calc_product_or_operator(visitor, node)
+                FoldAstPath::fold_calc_value_or_operators(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
+    fn fold_class_selector(
+        &mut self,
+        node: ClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassSelector {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_calc_product_or_operators(visitor, node)
+                FoldAstPath::fold_class_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_calc_product_or_operators(visitor, node)
+                FoldAstPath::fold_class_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_calc_sum(&mut self, node: &CalcSum) {
+    fn fold_cmyk_component(
+        &mut self,
+        node: CmykComponent,
+        __ast_path: &mut AstKindPath,
+    ) -> CmykComponent {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_calc_sum(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_calc_sum(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_cmyk_component(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_cmyk_component(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_calc_value(&mut self, node: &CalcValue) {
+    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_calc_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_calc_value(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_color(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_color(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
+    fn fold_color_profile_name(
+        &mut self,
+        node: ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) -> ColorProfileName {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_calc_value_or_operator(visitor, node)
+                FoldAstPath::fold_color_profile_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_calc_value_or_operator(visitor, node)
+                FoldAstPath::fold_color_profile_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
+    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_calc_value_or_operators(visitor, node)
+                FoldAstPath::fold_combinator(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_calc_value_or_operators(visitor, node)
+                FoldAstPath::fold_combinator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_class_selector(&mut self, node: &ClassSelector) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class_selector(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_cmyk_component(&mut self, node: &CmykComponent) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_cmyk_component(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_cmyk_component(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_color(&mut self, node: &Color) {
+    fn fold_combinator_value(
+        &mut self,
+        node: CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> CombinatorValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_color(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_color(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_combinator_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_combinator_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
+    fn fold_complex_selector(
+        &mut self,
+        node: ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_color_profile_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_color_profile_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_complex_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_complex_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_combinator(&mut self, node: &Combinator) {
+    fn fold_complex_selector_children(
+        &mut self,
+        node: ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelectorChildren {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_combinator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_combinator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_complex_selector_children(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_complex_selector_children(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_combinator_value(&mut self, node: &CombinatorValue) {
+    fn fold_complex_selector_childrens(
+        &mut self,
+        node: Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelectorChildren> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_combinator_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_combinator_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_complex_selector_childrens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_complex_selector_childrens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_complex_selector(&mut self, node: &ComplexSelector) {
+    fn fold_complex_selectors(
+        &mut self,
+        node: Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_complex_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_complex_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_complex_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_complex_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
+    fn fold_component_value(
+        &mut self,
+        node: ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) -> ComponentValue {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_complex_selector_children(visitor, node)
+                FoldAstPath::fold_component_value(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_complex_selector_children(visitor, node)
+                FoldAstPath::fold_component_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
+    fn fold_component_values(
+        &mut self,
+        node: Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComponentValue> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_complex_selector_childrens(visitor, node)
+                FoldAstPath::fold_component_values(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_complex_selector_childrens(visitor, node)
+                FoldAstPath::fold_component_values(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
+    fn fold_compound_selector(
+        &mut self,
+        node: CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_complex_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_complex_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_compound_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_compound_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_component_value(&mut self, node: &ComponentValue) {
+    fn fold_compound_selector_list(
+        &mut self,
+        node: CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_component_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_component_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_compound_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_compound_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_component_values(&mut self, node: &[ComponentValue]) {
+    fn fold_compound_selectors(
+        &mut self,
+        node: Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CompoundSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_component_values(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_component_values(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_compound_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_compound_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_compound_selector(&mut self, node: &CompoundSelector) {
+    fn fold_container_condition(
+        &mut self,
+        node: ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerCondition {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_compound_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_compound_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_container_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_container_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
+    fn fold_container_name(
+        &mut self,
+        node: ContainerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerName {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_compound_selector_list(visitor, node)
+                FoldAstPath::fold_container_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_compound_selector_list(visitor, node)
+                FoldAstPath::fold_container_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
+    fn fold_container_query(
+        &mut self,
+        node: ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQuery {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_compound_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_compound_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_container_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_container_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_container_condition(&mut self, node: &ContainerCondition) {
+    fn fold_container_query_and(
+        &mut self,
+        node: ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryAnd {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_container_condition(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_container_condition(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_container_query_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_container_query_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_container_name(&mut self, node: &ContainerName) {
+    fn fold_container_query_not(
+        &mut self,
+        node: ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryNot {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_container_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_container_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_container_query_not(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_container_query_not(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_container_query(&mut self, node: &ContainerQuery) {
+    fn fold_container_query_or(
+        &mut self,
+        node: ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryOr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_container_query(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_container_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_container_query_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_container_query_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
+    fn fold_container_query_type(
+        &mut self,
+        node: ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_container_query_and(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_container_query_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_container_query_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_container_query_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
+    fn fold_container_query_types(
+        &mut self,
+        node: Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ContainerQueryType> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_container_query_not(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_container_query_not(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_container_query_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_container_query_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
+    fn fold_custom_highlight_name(
+        &mut self,
+        node: CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomHighlightName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_container_query_or(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_container_query_or(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_custom_highlight_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_custom_highlight_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
+    fn fold_custom_ident(
+        &mut self,
+        node: CustomIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomIdent {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_container_query_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_custom_ident(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_container_query_type(visitor, node)
+                FoldAstPath::fold_custom_ident(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
+    fn fold_custom_idents(
+        &mut self,
+        node: Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CustomIdent> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_container_query_types(visitor, node)
+                FoldAstPath::fold_custom_idents(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_container_query_types(visitor, node)
+                FoldAstPath::fold_custom_idents(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
+    fn fold_custom_media_query(
+        &mut self,
+        node: CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQuery {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_custom_highlight_name(visitor, node)
+                FoldAstPath::fold_custom_media_query(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_custom_highlight_name(visitor, node)
+                FoldAstPath::fold_custom_media_query(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_custom_ident(&mut self, node: &CustomIdent) {
+    fn fold_custom_media_query_media_type(
+        &mut self,
+        node: CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQueryMediaType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_custom_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_custom_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_custom_media_query_media_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_custom_media_query_media_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
+    fn fold_custom_property_name(
+        &mut self,
+        node: CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomPropertyName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_custom_idents(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_custom_idents(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_custom_property_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_custom_property_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
+    fn fold_dashed_ident(
+        &mut self,
+        node: DashedIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> DashedIdent {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_custom_media_query(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_custom_media_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_dashed_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_dashed_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_custom_media_query_media_type(&mut self, node: &CustomMediaQueryMediaType) {
+    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_custom_media_query_media_type(visitor, node)
+                FoldAstPath::fold_declaration(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_custom_media_query_media_type(visitor, node)
+                FoldAstPath::fold_declaration(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
+    fn fold_declaration_name(
+        &mut self,
+        node: DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_custom_property_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_declaration_name(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_custom_property_name(visitor, node)
+                FoldAstPath::fold_declaration_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_dashed_ident(&mut self, node: &DashedIdent) {
+    fn fold_declaration_or_at_rule(
+        &mut self,
+        node: DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationOrAtRule {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_dashed_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_dashed_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_declaration_or_at_rule(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_declaration_or_at_rule(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_declaration(&mut self, node: &Declaration) {
+    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_declaration(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_declaration(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_delimiter(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_delimiter(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_declaration_name(&mut self, node: &DeclarationName) {
+    fn fold_delimiter_value(
+        &mut self,
+        node: DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) -> DelimiterValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_declaration_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_declaration_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_delimiter_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_delimiter_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
+    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_declaration_or_at_rule(visitor, node)
+                FoldAstPath::fold_dimension(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_declaration_or_at_rule(visitor, node)
+                FoldAstPath::fold_dimension(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_delimiter(&mut self, node: &Delimiter) {
+    fn fold_dimension_token(
+        &mut self,
+        node: DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) -> DimensionToken {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_delimiter(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_delimiter(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_dimension_token(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_dimension_token(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
+    fn fold_document_prelude(
+        &mut self,
+        node: DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPrelude {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_delimiter_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_delimiter_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_document_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_document_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_dimension(&mut self, node: &Dimension) {
+    fn fold_document_prelude_matching_function(
+        &mut self,
+        node: DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPreludeMatchingFunction {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_dimension(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_dimension(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_document_prelude_matching_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_document_prelude_matching_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_dimension_token(&mut self, node: &DimensionToken) {
+    fn fold_document_prelude_matching_functions(
+        &mut self,
+        node: Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<DocumentPreludeMatchingFunction> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_dimension_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_dimension_token(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_document_prelude_matching_functions(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_document_prelude_matching_functions(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
+    fn fold_extension_name(
+        &mut self,
+        node: ExtensionName,
+        __ast_path: &mut AstKindPath,
+    ) -> ExtensionName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_extension_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_extension_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_document_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
+    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_document_prelude_matching_function(visitor, node)
+                FoldAstPath::fold_family_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_document_prelude_matching_function(visitor, node)
+                FoldAstPath::fold_family_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_document_prelude_matching_functions(
+    fn fold_family_names(
         &mut self,
-        node: &[DocumentPreludeMatchingFunction],
-    ) {
+        node: Vec<FamilyName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<FamilyName> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_document_prelude_matching_functions(visitor, node)
+                FoldAstPath::fold_family_names(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_document_prelude_matching_functions(visitor, node)
+                FoldAstPath::fold_family_names(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_extension_name(&mut self, node: &ExtensionName) {
+    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_extension_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_extension_name(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_flex(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_flex(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_family_name(&mut self, node: &FamilyName) {
+    fn fold_font_feature_values_prelude(
+        &mut self,
+        node: FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> FontFeatureValuesPrelude {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_family_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_family_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_font_feature_values_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_font_feature_values_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_family_names(&mut self, node: &[FamilyName]) {
+    fn fold_forgiving_complex_selector(
+        &mut self,
+        node: ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingComplexSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_family_names(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_family_names(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_forgiving_complex_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_forgiving_complex_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_flex(&mut self, node: &Flex) {
+    fn fold_forgiving_complex_selectors(
+        &mut self,
+        node: Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingComplexSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_flex(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_flex(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_forgiving_complex_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_forgiving_complex_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
+    fn fold_forgiving_relative_selector(
+        &mut self,
+        node: ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelector {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_font_feature_values_prelude(visitor, node)
+                FoldAstPath::fold_forgiving_relative_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_font_feature_values_prelude(visitor, node)
+                FoldAstPath::fold_forgiving_relative_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
+    fn fold_forgiving_relative_selector_list(
+        &mut self,
+        node: ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelectorList {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_forgiving_complex_selector(visitor, node)
+                FoldAstPath::fold_forgiving_relative_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_forgiving_complex_selector(visitor, node)
+                FoldAstPath::fold_forgiving_relative_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
+    fn fold_forgiving_relative_selectors(
+        &mut self,
+        node: Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingRelativeSelector> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_forgiving_complex_selectors(visitor, node)
+                FoldAstPath::fold_forgiving_relative_selectors(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_forgiving_complex_selectors(visitor, node)
+                FoldAstPath::fold_forgiving_relative_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
+    fn fold_forgiving_selector_list(
+        &mut self,
+        node: ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingSelectorList {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_forgiving_relative_selector(visitor, node)
+                FoldAstPath::fold_forgiving_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_forgiving_relative_selector(visitor, node)
+                FoldAstPath::fold_forgiving_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
+    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_forgiving_relative_selector_list(visitor, node)
+                FoldAstPath::fold_frequency(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_forgiving_relative_selector_list(visitor, node)
+                FoldAstPath::fold_frequency(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
+    fn fold_frequency_percentage(
+        &mut self,
+        node: FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> FrequencyPercentage {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_forgiving_relative_selectors(visitor, node)
+                FoldAstPath::fold_frequency_percentage(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_forgiving_relative_selectors(visitor, node)
+                FoldAstPath::fold_frequency_percentage(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_forgiving_selector_list(visitor, node)
+                FoldAstPath::fold_function(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_forgiving_selector_list(visitor, node)
+                FoldAstPath::fold_function(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_frequency(&mut self, node: &Frequency) {
+    fn fold_function_name(
+        &mut self,
+        node: FunctionName,
+        __ast_path: &mut AstKindPath,
+    ) -> FunctionName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_frequency(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_frequency(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_function_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_function_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
+    fn fold_general_enclosed(
+        &mut self,
+        node: GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) -> GeneralEnclosed {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_frequency_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_general_enclosed(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_frequency_percentage(visitor, node)
+                FoldAstPath::fold_general_enclosed(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
+    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_function(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_hex_color(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_hex_color(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_function_name(&mut self, node: &FunctionName) {
+    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_function_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_function_name(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_hue(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_hue(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
+    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_general_enclosed(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_general_enclosed(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_id_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_id_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_hex_color(&mut self, node: &HexColor) {
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_hex_color(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_hex_color(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_hue(&mut self, node: &Hue) {
+    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_hue(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_hue(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_idents(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_idents(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_id_selector(&mut self, node: &IdSelector) {
+    fn fold_import_conditions(
+        &mut self,
+        node: ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportConditions {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_id_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_id_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_conditions(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_conditions(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
+    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_href(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_href(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_idents(&mut self, node: &[Ident]) {
+    fn fold_import_layer_name(
+        &mut self,
+        node: ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportLayerName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_idents(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_idents(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_layer_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_layer_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_conditions(&mut self, node: &ImportConditions) {
+    fn fold_import_prelude(
+        &mut self,
+        node: ImportPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPrelude {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_conditions(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_conditions(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_href(&mut self, node: &ImportHref) {
+    fn fold_important_flag(
+        &mut self,
+        node: ImportantFlag,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportantFlag {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_href(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_href(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_important_flag(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_important_flag(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
+    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_layer_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_layer_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_integer(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_integer(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_prelude(&mut self, node: &ImportPrelude) {
+    fn fold_keyframe_block(
+        &mut self,
+        node: KeyframeBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeBlock {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_keyframe_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_keyframe_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_important_flag(&mut self, node: &ImportantFlag) {
+    fn fold_keyframe_selector(
+        &mut self,
+        node: KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_important_flag(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_important_flag(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_keyframe_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_keyframe_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_integer(&mut self, node: &Integer) {
+    fn fold_keyframe_selectors(
+        &mut self,
+        node: Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<KeyframeSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_integer(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_integer(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_keyframe_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_keyframe_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
+    fn fold_keyframes_name(
+        &mut self,
+        node: KeyframesName,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_keyframe_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_keyframe_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_keyframes_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_keyframes_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
+    fn fold_keyframes_pseudo_function(
+        &mut self,
+        node: KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoFunction {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_keyframe_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_keyframe_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_keyframes_pseudo_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_keyframes_pseudo_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
+    fn fold_keyframes_pseudo_prefix(
+        &mut self,
+        node: KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoPrefix {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_keyframe_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_keyframe_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_keyframes_pseudo_prefix(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_keyframes_pseudo_prefix(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_keyframes_name(&mut self, node: &KeyframesName) {
+    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_keyframes_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_keyframes_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_layer_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_layer_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
+    fn fold_layer_name_list(
+        &mut self,
+        node: LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerNameList {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_keyframes_pseudo_function(visitor, node)
+                FoldAstPath::fold_layer_name_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_keyframes_pseudo_function(visitor, node)
+                FoldAstPath::fold_layer_name_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
+    fn fold_layer_names(
+        &mut self,
+        node: Vec<LayerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<LayerName> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_keyframes_pseudo_prefix(visitor, node)
+                FoldAstPath::fold_layer_names(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_keyframes_pseudo_prefix(visitor, node)
+                FoldAstPath::fold_layer_names(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_layer_name(&mut self, node: &LayerName) {
+    fn fold_layer_prelude(
+        &mut self,
+        node: LayerPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerPrelude {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_layer_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_layer_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_layer_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_layer_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_layer_name_list(&mut self, node: &LayerNameList) {
+    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_layer_name_list(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_layer_name_list(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_length(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_length(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_layer_names(&mut self, node: &[LayerName]) {
+    fn fold_length_percentage(
+        &mut self,
+        node: LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> LengthPercentage {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_layer_names(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_layer_names(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_length_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_length_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
+    fn fold_list_of_component_values(
+        &mut self,
+        node: ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) -> ListOfComponentValues {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_layer_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_layer_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_list_of_component_values(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_list_of_component_values(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_length(&mut self, node: &Length) {
+    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_length(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_length(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_length_percentage(&mut self, node: &LengthPercentage) {
+    fn fold_media_condition(
+        &mut self,
+        node: MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaCondition {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_length_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_length_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
+    fn fold_media_condition_all_type(
+        &mut self,
+        node: MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionAllType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_list_of_component_values(visitor, node)
+                FoldAstPath::fold_media_condition_all_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_list_of_component_values(visitor, node)
+                FoldAstPath::fold_media_condition_all_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_and(&mut self, node: &MediaAnd) {
+    fn fold_media_condition_all_types(
+        &mut self,
+        node: Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionAllType> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_and(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_condition_all_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_condition_all_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_condition(&mut self, node: &MediaCondition) {
+    fn fold_media_condition_type(
+        &mut self,
+        node: MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_condition(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_condition(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_condition_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_condition_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
+    fn fold_media_condition_without_or(
+        &mut self,
+        node: MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOr {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_condition_all_type(visitor, node)
+                FoldAstPath::fold_media_condition_without_or(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_condition_all_type(visitor, node)
+                FoldAstPath::fold_media_condition_without_or(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
+    fn fold_media_condition_without_or_type(
+        &mut self,
+        node: MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOrType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_condition_all_types(visitor, node)
+                FoldAstPath::fold_media_condition_without_or_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_condition_all_types(visitor, node)
+                FoldAstPath::fold_media_condition_without_or_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
+    fn fold_media_condition_without_or_types(
+        &mut self,
+        node: Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionWithoutOrType> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_condition_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_condition_without_or_types(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_condition_type(visitor, node)
+                FoldAstPath::fold_media_condition_without_or_types(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
+    fn fold_media_feature(
+        &mut self,
+        node: MediaFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeature {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_condition_without_or(visitor, node)
+                FoldAstPath::fold_media_feature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_condition_without_or(visitor, node)
+                FoldAstPath::fold_media_feature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_condition_without_or_type(&mut self, node: &MediaConditionWithoutOrType) {
+    fn fold_media_feature_boolean(
+        &mut self,
+        node: MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureBoolean {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_condition_without_or_type(visitor, node)
+                FoldAstPath::fold_media_feature_boolean(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_condition_without_or_type(visitor, node)
+                FoldAstPath::fold_media_feature_boolean(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_condition_without_or_types(&mut self, node: &[MediaConditionWithoutOrType]) {
+    fn fold_media_feature_name(
+        &mut self,
+        node: MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureName {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_condition_without_or_types(visitor, node)
+                FoldAstPath::fold_media_feature_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_condition_without_or_types(visitor, node)
+                FoldAstPath::fold_media_feature_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_feature(&mut self, node: &MediaFeature) {
+    fn fold_media_feature_plain(
+        &mut self,
+        node: MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeaturePlain {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_feature_plain(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_feature_plain(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
+    fn fold_media_feature_range(
+        &mut self,
+        node: MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRange {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_feature_boolean(visitor, node)
+                FoldAstPath::fold_media_feature_range(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_feature_boolean(visitor, node)
+                FoldAstPath::fold_media_feature_range(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
+    fn fold_media_feature_range_comparison(
+        &mut self,
+        node: MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeComparison {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_feature_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_feature_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_feature_range_comparison(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_feature_range_comparison(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
+    fn fold_media_feature_range_interval(
+        &mut self,
+        node: MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeInterval {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_feature_plain(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_feature_plain(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_feature_range_interval(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_feature_range_interval(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
+    fn fold_media_feature_value(
+        &mut self,
+        node: MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_feature_range(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_feature_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_feature_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_feature_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
+    fn fold_media_in_parens(
+        &mut self,
+        node: MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaInParens {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_feature_range_comparison(visitor, node)
+                FoldAstPath::fold_media_in_parens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_feature_range_comparison(visitor, node)
+                FoldAstPath::fold_media_in_parens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
+    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_media_feature_range_interval(visitor, node)
+                FoldAstPath::fold_media_not(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_media_feature_range_interval(visitor, node)
+                FoldAstPath::fold_media_not(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
+    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_feature_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_feature_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_in_parens(&mut self, node: &MediaInParens) {
+    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_in_parens(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_not(&mut self, node: &MediaNot) {
+    fn fold_media_query_list(
+        &mut self,
+        node: MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaQueryList {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_not(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_not(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_query_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_query_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_or(&mut self, node: &MediaOr) {
+    fn fold_media_querys(
+        &mut self,
+        node: Vec<MediaQuery>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaQuery> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_or(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_or(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_querys(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_querys(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_query(&mut self, node: &MediaQuery) {
+    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_query(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_media_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_media_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_query_list(&mut self, node: &MediaQueryList) {
+    fn fold_named_namespace(
+        &mut self,
+        node: NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedNamespace {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_query_list(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_query_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_named_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_named_namespace(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_querys(&mut self, node: &[MediaQuery]) {
+    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_querys(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_querys(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_namespace(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_namespace(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_media_type(&mut self, node: &MediaType) {
+    fn fold_namespace_prefix(
+        &mut self,
+        node: NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrefix {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_media_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_media_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_namespace_prefix(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_namespace_prefix(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_named_namespace(&mut self, node: &NamedNamespace) {
+    fn fold_namespace_prelude(
+        &mut self,
+        node: NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrelude {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_named_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_named_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_namespace_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_namespace_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
+    fn fold_namespace_prelude_uri(
+        &mut self,
+        node: NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePreludeUri {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_namespace_prelude_uri(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_namespace_prelude_uri(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
+    fn fold_nesting_selector(
+        &mut self,
+        node: NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> NestingSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_namespace_prefix(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_namespace_prefix(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_nesting_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_nesting_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_namespace_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_namespace_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_number(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_number(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
+    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_namespace_prelude_uri(visitor, node)
+                FoldAstPath::fold_number_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_namespace_prelude_uri(visitor, node)
+                FoldAstPath::fold_number_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_nesting_selector(&mut self, node: &NestingSelector) {
+    fn fold_opt_at_rule_prelude(
+        &mut self,
+        node: Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<AtRulePrelude>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_nesting_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_nesting_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_at_rule_prelude(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_at_rule_prelude(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_number(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_number_type(&mut self, node: &NumberType) {
+    fn fold_opt_attribute_selector_matcher(
+        &mut self,
+        node: Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorMatcher> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_number_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_number_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_attribute_selector_matcher(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_attribute_selector_matcher(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>) {
+    fn fold_opt_attribute_selector_modifier(
+        &mut self,
+        node: Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorModifier> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_at_rule_prelude(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_at_rule_prelude(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_attribute_selector_modifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_attribute_selector_modifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
+    fn fold_opt_attribute_selector_value(
+        &mut self,
+        node: Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorValue> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_attribute_selector_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_attribute_selector_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_matcher(&mut self, node: &Option<AttributeSelectorMatcher>) {
+    fn fold_opt_combinator(
+        &mut self,
+        node: Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Combinator> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_attribute_selector_matcher(visitor, node)
+                FoldAstPath::fold_opt_combinator(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_attribute_selector_matcher(visitor, node)
+                FoldAstPath::fold_opt_combinator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_modifier(&mut self, node: &Option<AttributeSelectorModifier>) {
+    fn fold_opt_container_name(
+        &mut self,
+        node: Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ContainerName> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_attribute_selector_modifier(visitor, node)
+                FoldAstPath::fold_opt_container_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_attribute_selector_modifier(visitor, node)
+                FoldAstPath::fold_opt_container_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_value(&mut self, node: &Option<AttributeSelectorValue>) {
+    fn fold_opt_forgiving_selector_list(
+        &mut self,
+        node: Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ForgivingSelectorList> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_attribute_selector_value(visitor, node)
+                FoldAstPath::fold_opt_forgiving_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_attribute_selector_value(visitor, node)
+                FoldAstPath::fold_opt_forgiving_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
+    fn fold_opt_function(
+        &mut self,
+        node: Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Function>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_combinator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_combinator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_container_name(&mut self, node: &Option<ContainerName>) {
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_container_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_container_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_forgiving_selector_list(&mut self, node: &Option<ForgivingSelectorList>) {
+    fn fold_opt_import_conditions(
+        &mut self,
+        node: Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportConditions>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_forgiving_selector_list(visitor, node)
+                FoldAstPath::fold_opt_import_conditions(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_forgiving_selector_list(visitor, node)
+                FoldAstPath::fold_opt_import_conditions(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_function(&mut self, node: &Option<Box<Function>>) {
+    fn fold_opt_import_layer_name(
+        &mut self,
+        node: Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportLayerName>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_function(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_import_layer_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_import_layer_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
+    fn fold_opt_important_flag(
+        &mut self,
+        node: Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ImportantFlag> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_important_flag(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_important_flag(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>) {
+    fn fold_opt_media_condition_type(
+        &mut self,
+        node: Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaConditionType>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_import_conditions(visitor, node)
+                FoldAstPath::fold_opt_media_condition_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_import_conditions(visitor, node)
+                FoldAstPath::fold_opt_media_condition_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>) {
+    fn fold_opt_media_query_list(
+        &mut self,
+        node: Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaQueryList>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_import_layer_name(visitor, node)
+                FoldAstPath::fold_opt_media_query_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_import_layer_name(visitor, node)
+                FoldAstPath::fold_opt_media_query_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>) {
+    fn fold_opt_media_type(
+        &mut self,
+        node: Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<MediaType> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_important_flag(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_important_flag(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_media_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_media_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_media_condition_type(&mut self, node: &Option<Box<MediaConditionType>>) {
+    fn fold_opt_namespace(
+        &mut self,
+        node: Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Namespace> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_media_condition_type(visitor, node)
+                FoldAstPath::fold_opt_namespace(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_media_condition_type(visitor, node)
+                FoldAstPath::fold_opt_namespace(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>) {
+    fn fold_opt_namespace_prefix(
+        &mut self,
+        node: Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NamespacePrefix> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_media_query_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_namespace_prefix(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_media_query_list(visitor, node)
+                FoldAstPath::fold_opt_namespace_prefix(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_media_type(&mut self, node: &Option<MediaType>) {
+    fn fold_opt_nesting_selector(
+        &mut self,
+        node: Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NestingSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_media_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_media_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_nesting_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_nesting_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
+    fn fold_opt_number(
+        &mut self,
+        node: Option<Number>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Number> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_namespace(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_number(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_number(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_namespace_prefix(&mut self, node: &Option<NamespacePrefix>) {
+    fn fold_opt_page_selector_pseudos(
+        &mut self,
+        node: Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PageSelectorPseudo>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_namespace_prefix(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_page_selector_pseudos(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_namespace_prefix(visitor, node)
+                FoldAstPath::fold_opt_page_selector_pseudos(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_nesting_selector(&mut self, node: &Option<NestingSelector>) {
+    fn fold_opt_page_selector_type(
+        &mut self,
+        node: Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<PageSelectorType> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_nesting_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_page_selector_type(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_nesting_selector(visitor, node)
+                FoldAstPath::fold_opt_page_selector_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_number(&mut self, node: &Option<Number>) {
+    fn fold_opt_pseudo_class_selector_childrens(
+        &mut self,
+        node: Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoClassSelectorChildren>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_number(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_pseudo_class_selector_childrens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_page_selector_pseudos(&mut self, node: &Option<Vec<PageSelectorPseudo>>) {
+    fn fold_opt_pseudo_element_selector_childrens(
+        &mut self,
+        node: Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoElementSelectorChildren>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_page_selector_pseudos(visitor, node)
+                FoldAstPath::fold_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_page_selector_pseudos(visitor, node)
+                FoldAstPath::fold_opt_pseudo_element_selector_childrens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_page_selector_type(&mut self, node: &Option<PageSelectorType>) {
+    fn fold_opt_simple_block(
+        &mut self,
+        node: Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<SimpleBlock> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_page_selector_type(visitor, node)
+                FoldAstPath::fold_opt_simple_block(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_page_selector_type(visitor, node)
+                FoldAstPath::fold_opt_simple_block(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_pseudo_class_selector_childrens(
+    fn fold_opt_type_selector(
         &mut self,
-        node: &Option<Vec<PseudoClassSelectorChildren>>,
-    ) {
+        node: Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TypeSelector>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_pseudo_class_selector_childrens(visitor, node)
+                FoldAstPath::fold_opt_type_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_pseudo_class_selector_childrens(visitor, node)
+                FoldAstPath::fold_opt_type_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_pseudo_element_selector_childrens(
+    fn fold_opt_url_modifiers(
         &mut self,
-        node: &Option<Vec<PseudoElementSelectorChildren>>,
-    ) {
+        node: Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<UrlModifier>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_pseudo_element_selector_childrens(visitor, node)
+                FoldAstPath::fold_opt_url_modifiers(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_pseudo_element_selector_childrens(visitor, node)
+                FoldAstPath::fold_opt_url_modifiers(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>) {
+    fn fold_opt_url_value(
+        &mut self,
+        node: Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<UrlValue>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_simple_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_simple_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_url_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_url_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>) {
+    fn fold_page_selector(
+        &mut self,
+        node: PageSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_type_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_type_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_page_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_page_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>) {
+    fn fold_page_selector_list(
+        &mut self,
+        node: PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_url_modifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_url_modifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_page_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_page_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_url_value(&mut self, node: &Option<Box<UrlValue>>) {
+    fn fold_page_selector_pseudo(
+        &mut self,
+        node: PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorPseudo {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_url_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_url_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_page_selector_pseudo(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_page_selector_pseudo(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_page_selector(&mut self, node: &PageSelector) {
+    fn fold_page_selector_pseudos(
+        &mut self,
+        node: Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelectorPseudo> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_page_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_page_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_page_selector_pseudos(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_page_selector_pseudos(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
+    fn fold_page_selector_type(
+        &mut self,
+        node: PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_page_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_page_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_page_selector_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_page_selector_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
+    fn fold_page_selectors(
+        &mut self,
+        node: Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_page_selector_pseudo(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_page_selectors(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_page_selector_pseudo(visitor, node)
+                FoldAstPath::fold_page_selectors(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
+    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_page_selector_pseudos(visitor, node)
+                FoldAstPath::fold_percentage(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_page_selector_pseudos(visitor, node)
+                FoldAstPath::fold_percentage(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
+    fn fold_pseudo_class_selector(
+        &mut self,
+        node: PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_page_selector_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_page_selector_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_pseudo_class_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_pseudo_class_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_page_selectors(&mut self, node: &[PageSelector]) {
+    fn fold_pseudo_class_selector_children(
+        &mut self,
+        node: PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelectorChildren {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_page_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_page_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_pseudo_class_selector_children(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_pseudo_class_selector_children(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_percentage(&mut self, node: &Percentage) {
+    fn fold_pseudo_class_selector_childrens(
+        &mut self,
+        node: Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoClassSelectorChildren> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_pseudo_class_selector_childrens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_pseudo_class_selector_childrens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
+    fn fold_pseudo_element_selector(
+        &mut self,
+        node: PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelector {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_pseudo_class_selector(visitor, node)
+                FoldAstPath::fold_pseudo_element_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_pseudo_class_selector(visitor, node)
+                FoldAstPath::fold_pseudo_element_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
+    fn fold_pseudo_element_selector_children(
+        &mut self,
+        node: PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelectorChildren {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_pseudo_class_selector_children(visitor, node)
+                FoldAstPath::fold_pseudo_element_selector_children(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_pseudo_class_selector_children(visitor, node)
+                FoldAstPath::fold_pseudo_element_selector_children(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
+    fn fold_pseudo_element_selector_childrens(
+        &mut self,
+        node: Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoElementSelectorChildren> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_pseudo_class_selector_childrens(visitor, node)
+                FoldAstPath::fold_pseudo_element_selector_childrens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_pseudo_class_selector_childrens(visitor, node)
+                FoldAstPath::fold_pseudo_element_selector_childrens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
+    fn fold_qualified_rule(
+        &mut self,
+        node: QualifiedRule,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRule {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_pseudo_element_selector(visitor, node)
+                FoldAstPath::fold_qualified_rule(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_pseudo_element_selector(visitor, node)
+                FoldAstPath::fold_qualified_rule(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
+    fn fold_qualified_rule_prelude(
+        &mut self,
+        node: QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRulePrelude {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_pseudo_element_selector_children(visitor, node)
+                FoldAstPath::fold_qualified_rule_prelude(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_pseudo_element_selector_children(visitor, node)
+                FoldAstPath::fold_qualified_rule_prelude(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
+    fn fold_query_in_parens(
+        &mut self,
+        node: QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> QueryInParens {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_pseudo_element_selector_childrens(visitor, node)
+                FoldAstPath::fold_query_in_parens(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_pseudo_element_selector_childrens(visitor, node)
+                FoldAstPath::fold_query_in_parens(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
+    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_qualified_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_qualified_rule(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ratio(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_ratio(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
+    fn fold_relative_selector(
+        &mut self,
+        node: RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelector {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_qualified_rule_prelude(visitor, node)
+                FoldAstPath::fold_relative_selector(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_qualified_rule_prelude(visitor, node)
+                FoldAstPath::fold_relative_selector(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_query_in_parens(&mut self, node: &QueryInParens) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_query_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_query_in_parens(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_ratio(&mut self, node: &Ratio) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ratio(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ratio(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selector(&mut self, node: &RelativeSelector) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_relative_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_relative_selector(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
+    fn fold_relative_selector_list(
+        &mut self,
+        node: RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelectorList {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_relative_selector_list(visitor, node)
+                FoldAstPath::fold_relative_selector_list(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_relative_selector_list(visitor, node)
+                FoldAstPath::fold_relative_selector_list(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
+    fn fold_relative_selectors(
+        &mut self,
+        node: Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<RelativeSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_relative_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_relative_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_relative_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_relative_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_resolution(&mut self, node: &Resolution) {
+    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_resolution(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_resolution(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_resolution(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_resolution(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_rule(&mut self, node: &Rule) {
+    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_rule(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_rule(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_rule(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_rule(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_rules(&mut self, node: &[Rule]) {
+    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_rules(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_rules(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_rules(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_rules(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_scope_range(&mut self, node: &ScopeRange) {
+    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_scope_range(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_scope_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_scope_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_scope_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_selector_list(&mut self, node: &SelectorList) {
+    fn fold_selector_list(
+        &mut self,
+        node: SelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> SelectorList {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_selector_list(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_selector_list(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_selector_list(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_selector_list(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
+    fn fold_sequence_of_custom_idents(
+        &mut self,
+        node: SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) -> SequenceOfCustomIdents {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_sequence_of_custom_idents(visitor, node)
+                FoldAstPath::fold_sequence_of_custom_idents(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_sequence_of_custom_idents(visitor, node)
+                FoldAstPath::fold_sequence_of_custom_idents(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_simple_block(&mut self, node: &SimpleBlock) {
+    fn fold_simple_block(
+        &mut self,
+        node: SimpleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleBlock {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_simple_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_simple_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_simple_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_simple_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_size_feature(&mut self, node: &SizeFeature) {
+    fn fold_size_feature(
+        &mut self,
+        node: SizeFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeature {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_size_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_size_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_size_feature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_size_feature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
+    fn fold_size_feature_boolean(
+        &mut self,
+        node: SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureBoolean {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_size_feature_boolean(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_size_feature_boolean(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_size_feature_boolean(visitor, node)
+                FoldAstPath::fold_size_feature_boolean(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
+    fn fold_size_feature_name(
+        &mut self,
+        node: SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_size_feature_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_size_feature_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_size_feature_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_size_feature_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
+    fn fold_size_feature_plain(
+        &mut self,
+        node: SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeaturePlain {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_size_feature_plain(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_size_feature_plain(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_size_feature_plain(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_size_feature_plain(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
+    fn fold_size_feature_range(
+        &mut self,
+        node: SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRange {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_size_feature_range(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_size_feature_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_size_feature_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_size_feature_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
+    fn fold_size_feature_range_comparison(
+        &mut self,
+        node: SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeComparison {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_size_feature_range_comparison(visitor, node)
+                FoldAstPath::fold_size_feature_range_comparison(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_size_feature_range_comparison(visitor, node)
+                FoldAstPath::fold_size_feature_range_comparison(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
+    fn fold_size_feature_range_interval(
+        &mut self,
+        node: SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeInterval {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_size_feature_range_interval(visitor, node)
+                FoldAstPath::fold_size_feature_range_interval(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_size_feature_range_interval(visitor, node)
+                FoldAstPath::fold_size_feature_range_interval(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
+    fn fold_size_feature_value(
+        &mut self,
+        node: SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_size_feature_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_size_feature_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_size_feature_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_size_feature_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_span(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_str(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_str(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_style_block(&mut self, node: &StyleBlock) {
+    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_style_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_style_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_style_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_style_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_stylesheet(&mut self, node: &Stylesheet) {
+    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_stylesheet(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_stylesheet(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_stylesheet(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_stylesheet(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
+    fn fold_subclass_selector(
+        &mut self,
+        node: SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> SubclassSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_subclass_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_subclass_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_subclass_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_subclass_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
+    fn fold_subclass_selectors(
+        &mut self,
+        node: Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SubclassSelector> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_subclass_selectors(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_subclass_selectors(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_subclass_selectors(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_subclass_selectors(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_supports_and(&mut self, node: &SupportsAnd) {
+    fn fold_supports_and(
+        &mut self,
+        node: SupportsAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsAnd {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_supports_and(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_supports_and(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_supports_and(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_supports_and(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_supports_condition(&mut self, node: &SupportsCondition) {
+    fn fold_supports_condition(
+        &mut self,
+        node: SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsCondition {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_supports_condition(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_supports_condition(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_supports_condition(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_supports_condition(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
+    fn fold_supports_condition_type(
+        &mut self,
+        node: SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsConditionType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_supports_condition_type(visitor, node)
+                FoldAstPath::fold_supports_condition_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_supports_condition_type(visitor, node)
+                FoldAstPath::fold_supports_condition_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
+    fn fold_supports_condition_types(
+        &mut self,
+        node: Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SupportsConditionType> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_supports_condition_types(visitor, node)
+                FoldAstPath::fold_supports_condition_types(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_supports_condition_types(visitor, node)
+                FoldAstPath::fold_supports_condition_types(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_supports_feature(&mut self, node: &SupportsFeature) {
+    fn fold_supports_feature(
+        &mut self,
+        node: SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsFeature {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_supports_feature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_supports_feature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_supports_feature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_supports_feature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
+    fn fold_supports_in_parens(
+        &mut self,
+        node: SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsInParens {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_supports_in_parens(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_supports_in_parens(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_supports_in_parens(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_supports_in_parens(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_supports_not(&mut self, node: &SupportsNot) {
+    fn fold_supports_not(
+        &mut self,
+        node: SupportsNot,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsNot {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_supports_not(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_supports_not(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_supports_not(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_supports_not(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_supports_or(&mut self, node: &SupportsOr) {
+    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_supports_or(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_supports_or(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_supports_or(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_supports_or(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
+    fn fold_tag_name_selector(
+        &mut self,
+        node: TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TagNameSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_tag_name_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_tag_name_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_tag_name_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_tag_name_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_time(&mut self, node: &Time) {
+    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_time(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_time(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_time(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_time(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_time_percentage(&mut self, node: &TimePercentage) {
+    fn fold_time_percentage(
+        &mut self,
+        node: TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> TimePercentage {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_time_percentage(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_time_percentage(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_time_percentage(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_time_percentage(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_token(&mut self, node: &Token) {
+    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_token(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_token(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_token(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
+    fn fold_token_and_span(
+        &mut self,
+        node: TokenAndSpan,
+        __ast_path: &mut AstKindPath,
+    ) -> TokenAndSpan {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_token_and_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_token_and_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_token_and_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_token_and_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_type_selector(&mut self, node: &TypeSelector) {
+    fn fold_type_selector(
+        &mut self,
+        node: TypeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TypeSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_type_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_type_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_type_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_type_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_unicode_range(&mut self, node: &UnicodeRange) {
+    fn fold_unicode_range(
+        &mut self,
+        node: UnicodeRange,
+        __ast_path: &mut AstKindPath,
+    ) -> UnicodeRange {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_unicode_range(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_unicode_range(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_unicode_range(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_unicode_range(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_universal_selector(&mut self, node: &UniversalSelector) {
+    fn fold_universal_selector(
+        &mut self,
+        node: UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> UniversalSelector {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_universal_selector(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_universal_selector(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_universal_selector(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_universal_selector(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
+    fn fold_unknown_dimension(
+        &mut self,
+        node: UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) -> UnknownDimension {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_unknown_dimension(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_unknown_dimension(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_unknown_dimension(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_unknown_dimension(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_url(&mut self, node: &Url) {
+    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_url(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_url(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_url(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_url(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
+    fn fold_url_key_value(
+        &mut self,
+        node: UrlKeyValue,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlKeyValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_url_key_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_url_key_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_url_key_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_url_key_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_url_modifier(&mut self, node: &UrlModifier) {
+    fn fold_url_modifier(
+        &mut self,
+        node: UrlModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlModifier {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_url_modifier(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_url_modifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_url_modifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_url_modifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
+    fn fold_url_modifiers(
+        &mut self,
+        node: Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<UrlModifier> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_url_modifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_url_modifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_url_modifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_url_modifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_url_value(&mut self, node: &UrlValue) {
+    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_url_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_url_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_url_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_url_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
+    fn fold_url_value_raw(
+        &mut self,
+        node: UrlValueRaw,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlValueRaw {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_url_value_raw(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_url_value_raw(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_url_value_raw(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_url_value_raw(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_wq_name(&mut self, node: &WqName) {
+    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_wq_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_wq_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_wq_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_wq_name(visitor, node, __ast_path)
+            }
         }
     }
 }
-impl<V> VisitAll for ::swc_visit::Optional<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> FoldAstPath for ::swc_visit::Optional<V>
 where
-    V: VisitAll,
+    V: FoldAstPath,
 {
     #[inline]
-    fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
+    fn fold_absolute_color_base(
+        &mut self,
+        node: AbsoluteColorBase,
+        __ast_path: &mut AstKindPath,
+    ) -> AbsoluteColorBase {
         if self.enabled {
-            <V as VisitAll>::visit_absolute_color_base(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_absolute_color_base(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_alpha_value(&mut self, node: &AlphaValue) {
+    fn fold_alpha_value(&mut self, node: AlphaValue, __ast_path: &mut AstKindPath) -> AlphaValue {
         if self.enabled {
-            <V as VisitAll>::visit_alpha_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_alpha_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_an_plus_b(&mut self, node: &AnPlusB) {
+    fn fold_an_plus_b(&mut self, node: AnPlusB, __ast_path: &mut AstKindPath) -> AnPlusB {
         if self.enabled {
-            <V as VisitAll>::visit_an_plus_b(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_an_plus_b(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
+    fn fold_an_plus_b_notation(
+        &mut self,
+        node: AnPlusBNotation,
+        __ast_path: &mut AstKindPath,
+    ) -> AnPlusBNotation {
         if self.enabled {
-            <V as VisitAll>::visit_an_plus_b_notation(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_an_plus_b_notation(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_angle(&mut self, node: &Angle) {
+    fn fold_angle(&mut self, node: Angle, __ast_path: &mut AstKindPath) -> Angle {
         if self.enabled {
-            <V as VisitAll>::visit_angle(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_angle(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
+    fn fold_angle_percentage(
+        &mut self,
+        node: AnglePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> AnglePercentage {
         if self.enabled {
-            <V as VisitAll>::visit_angle_percentage(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_angle_percentage(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_any_namespace(&mut self, node: &AnyNamespace) {
+    fn fold_any_namespace(
+        &mut self,
+        node: AnyNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> AnyNamespace {
         if self.enabled {
-            <V as VisitAll>::visit_any_namespace(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_any_namespace(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_at_rule(&mut self, node: &AtRule) {
+    fn fold_at_rule(&mut self, node: AtRule, __ast_path: &mut AstKindPath) -> AtRule {
         if self.enabled {
-            <V as VisitAll>::visit_at_rule(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_at_rule(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_at_rule_name(&mut self, node: &AtRuleName) {
+    fn fold_at_rule_name(&mut self, node: AtRuleName, __ast_path: &mut AstKindPath) -> AtRuleName {
         if self.enabled {
-            <V as VisitAll>::visit_at_rule_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_at_rule_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
+    fn fold_at_rule_prelude(
+        &mut self,
+        node: AtRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> AtRulePrelude {
         if self.enabled {
-            <V as VisitAll>::visit_at_rule_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_at_rule_prelude(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
         if self.enabled {
-            <V as VisitAll>::visit_atom(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_atom(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
+    fn fold_attribute_selector(
+        &mut self,
+        node: AttributeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelector {
         if self.enabled {
-            <V as VisitAll>::visit_attribute_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_attribute_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
+    fn fold_attribute_selector_matcher(
+        &mut self,
+        node: AttributeSelectorMatcher,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcher {
         if self.enabled {
-            <V as VisitAll>::visit_attribute_selector_matcher(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_attribute_selector_matcher(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
+    fn fold_attribute_selector_matcher_value(
+        &mut self,
+        node: AttributeSelectorMatcherValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorMatcherValue {
         if self.enabled {
-            <V as VisitAll>::visit_attribute_selector_matcher_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_attribute_selector_matcher_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
+    fn fold_attribute_selector_modifier(
+        &mut self,
+        node: AttributeSelectorModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorModifier {
         if self.enabled {
-            <V as VisitAll>::visit_attribute_selector_modifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_attribute_selector_modifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
+    fn fold_attribute_selector_value(
+        &mut self,
+        node: AttributeSelectorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> AttributeSelectorValue {
         if self.enabled {
-            <V as VisitAll>::visit_attribute_selector_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_attribute_selector_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_bin_op(&mut self, node: &BinOp) {
+    fn fold_bin_op(&mut self, node: BinOp, __ast_path: &mut AstKindPath) -> BinOp {
         if self.enabled {
-            <V as VisitAll>::visit_bin_op(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_bin_op(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_operator(&mut self, node: &CalcOperator) {
+    fn fold_calc_operator(
+        &mut self,
+        node: CalcOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperator {
         if self.enabled {
-            <V as VisitAll>::visit_calc_operator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_operator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
+    fn fold_calc_operator_type(
+        &mut self,
+        node: CalcOperatorType,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcOperatorType {
         if self.enabled {
-            <V as VisitAll>::visit_calc_operator_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_operator_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_product(&mut self, node: &CalcProduct) {
+    fn fold_calc_product(
+        &mut self,
+        node: CalcProduct,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProduct {
         if self.enabled {
-            <V as VisitAll>::visit_calc_product(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_product(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
+    fn fold_calc_product_or_operator(
+        &mut self,
+        node: CalcProductOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcProductOrOperator {
         if self.enabled {
-            <V as VisitAll>::visit_calc_product_or_operator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_product_or_operator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
+    fn fold_calc_product_or_operators(
+        &mut self,
+        node: Vec<CalcProductOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcProductOrOperator> {
         if self.enabled {
-            <V as VisitAll>::visit_calc_product_or_operators(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_product_or_operators(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_sum(&mut self, node: &CalcSum) {
+    fn fold_calc_sum(&mut self, node: CalcSum, __ast_path: &mut AstKindPath) -> CalcSum {
         if self.enabled {
-            <V as VisitAll>::visit_calc_sum(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_sum(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_value(&mut self, node: &CalcValue) {
+    fn fold_calc_value(&mut self, node: CalcValue, __ast_path: &mut AstKindPath) -> CalcValue {
         if self.enabled {
-            <V as VisitAll>::visit_calc_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
+    fn fold_calc_value_or_operator(
+        &mut self,
+        node: CalcValueOrOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> CalcValueOrOperator {
         if self.enabled {
-            <V as VisitAll>::visit_calc_value_or_operator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_value_or_operator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
+    fn fold_calc_value_or_operators(
+        &mut self,
+        node: Vec<CalcValueOrOperator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CalcValueOrOperator> {
         if self.enabled {
-            <V as VisitAll>::visit_calc_value_or_operators(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_calc_value_or_operators(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class_selector(&mut self, node: &ClassSelector) {
+    fn fold_class_selector(
+        &mut self,
+        node: ClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassSelector {
         if self.enabled {
-            <V as VisitAll>::visit_class_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_cmyk_component(&mut self, node: &CmykComponent) {
+    fn fold_cmyk_component(
+        &mut self,
+        node: CmykComponent,
+        __ast_path: &mut AstKindPath,
+    ) -> CmykComponent {
         if self.enabled {
-            <V as VisitAll>::visit_cmyk_component(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_cmyk_component(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_color(&mut self, node: &Color) {
+    fn fold_color(&mut self, node: Color, __ast_path: &mut AstKindPath) -> Color {
         if self.enabled {
-            <V as VisitAll>::visit_color(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_color(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
+    fn fold_color_profile_name(
+        &mut self,
+        node: ColorProfileName,
+        __ast_path: &mut AstKindPath,
+    ) -> ColorProfileName {
         if self.enabled {
-            <V as VisitAll>::visit_color_profile_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_color_profile_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_combinator(&mut self, node: &Combinator) {
+    fn fold_combinator(&mut self, node: Combinator, __ast_path: &mut AstKindPath) -> Combinator {
         if self.enabled {
-            <V as VisitAll>::visit_combinator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_combinator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_combinator_value(&mut self, node: &CombinatorValue) {
+    fn fold_combinator_value(
+        &mut self,
+        node: CombinatorValue,
+        __ast_path: &mut AstKindPath,
+    ) -> CombinatorValue {
         if self.enabled {
-            <V as VisitAll>::visit_combinator_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_combinator_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_complex_selector(&mut self, node: &ComplexSelector) {
+    fn fold_complex_selector(
+        &mut self,
+        node: ComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelector {
         if self.enabled {
-            <V as VisitAll>::visit_complex_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_complex_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
+    fn fold_complex_selector_children(
+        &mut self,
+        node: ComplexSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> ComplexSelectorChildren {
         if self.enabled {
-            <V as VisitAll>::visit_complex_selector_children(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_complex_selector_children(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
+    fn fold_complex_selector_childrens(
+        &mut self,
+        node: Vec<ComplexSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelectorChildren> {
         if self.enabled {
-            <V as VisitAll>::visit_complex_selector_childrens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_complex_selector_childrens(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
+    fn fold_complex_selectors(
+        &mut self,
+        node: Vec<ComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComplexSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_complex_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_complex_selectors(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_component_value(&mut self, node: &ComponentValue) {
+    fn fold_component_value(
+        &mut self,
+        node: ComponentValue,
+        __ast_path: &mut AstKindPath,
+    ) -> ComponentValue {
         if self.enabled {
-            <V as VisitAll>::visit_component_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_component_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_component_values(&mut self, node: &[ComponentValue]) {
+    fn fold_component_values(
+        &mut self,
+        node: Vec<ComponentValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ComponentValue> {
         if self.enabled {
-            <V as VisitAll>::visit_component_values(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_component_values(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_compound_selector(&mut self, node: &CompoundSelector) {
+    fn fold_compound_selector(
+        &mut self,
+        node: CompoundSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelector {
         if self.enabled {
-            <V as VisitAll>::visit_compound_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_compound_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
+    fn fold_compound_selector_list(
+        &mut self,
+        node: CompoundSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> CompoundSelectorList {
         if self.enabled {
-            <V as VisitAll>::visit_compound_selector_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_compound_selector_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
+    fn fold_compound_selectors(
+        &mut self,
+        node: Vec<CompoundSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CompoundSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_compound_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_compound_selectors(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_condition(&mut self, node: &ContainerCondition) {
+    fn fold_container_condition(
+        &mut self,
+        node: ContainerCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerCondition {
         if self.enabled {
-            <V as VisitAll>::visit_container_condition(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_condition(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_name(&mut self, node: &ContainerName) {
+    fn fold_container_name(
+        &mut self,
+        node: ContainerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerName {
         if self.enabled {
-            <V as VisitAll>::visit_container_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_query(&mut self, node: &ContainerQuery) {
+    fn fold_container_query(
+        &mut self,
+        node: ContainerQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQuery {
         if self.enabled {
-            <V as VisitAll>::visit_container_query(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_query(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
+    fn fold_container_query_and(
+        &mut self,
+        node: ContainerQueryAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryAnd {
         if self.enabled {
-            <V as VisitAll>::visit_container_query_and(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_query_and(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
+    fn fold_container_query_not(
+        &mut self,
+        node: ContainerQueryNot,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryNot {
         if self.enabled {
-            <V as VisitAll>::visit_container_query_not(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_query_not(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
+    fn fold_container_query_or(
+        &mut self,
+        node: ContainerQueryOr,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryOr {
         if self.enabled {
-            <V as VisitAll>::visit_container_query_or(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_query_or(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
+    fn fold_container_query_type(
+        &mut self,
+        node: ContainerQueryType,
+        __ast_path: &mut AstKindPath,
+    ) -> ContainerQueryType {
         if self.enabled {
-            <V as VisitAll>::visit_container_query_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_query_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
+    fn fold_container_query_types(
+        &mut self,
+        node: Vec<ContainerQueryType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ContainerQueryType> {
         if self.enabled {
-            <V as VisitAll>::visit_container_query_types(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_container_query_types(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
+    fn fold_custom_highlight_name(
+        &mut self,
+        node: CustomHighlightName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomHighlightName {
         if self.enabled {
-            <V as VisitAll>::visit_custom_highlight_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_custom_highlight_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_custom_ident(&mut self, node: &CustomIdent) {
+    fn fold_custom_ident(
+        &mut self,
+        node: CustomIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomIdent {
         if self.enabled {
-            <V as VisitAll>::visit_custom_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_custom_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
+    fn fold_custom_idents(
+        &mut self,
+        node: Vec<CustomIdent>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<CustomIdent> {
         if self.enabled {
-            <V as VisitAll>::visit_custom_idents(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_custom_idents(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
+    fn fold_custom_media_query(
+        &mut self,
+        node: CustomMediaQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQuery {
         if self.enabled {
-            <V as VisitAll>::visit_custom_media_query(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_custom_media_query(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_custom_media_query_media_type(&mut self, node: &CustomMediaQueryMediaType) {
+    fn fold_custom_media_query_media_type(
+        &mut self,
+        node: CustomMediaQueryMediaType,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomMediaQueryMediaType {
         if self.enabled {
-            <V as VisitAll>::visit_custom_media_query_media_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_custom_media_query_media_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
+    fn fold_custom_property_name(
+        &mut self,
+        node: CustomPropertyName,
+        __ast_path: &mut AstKindPath,
+    ) -> CustomPropertyName {
         if self.enabled {
-            <V as VisitAll>::visit_custom_property_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_custom_property_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_dashed_ident(&mut self, node: &DashedIdent) {
+    fn fold_dashed_ident(
+        &mut self,
+        node: DashedIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> DashedIdent {
         if self.enabled {
-            <V as VisitAll>::visit_dashed_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_dashed_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_declaration(&mut self, node: &Declaration) {
+    fn fold_declaration(&mut self, node: Declaration, __ast_path: &mut AstKindPath) -> Declaration {
         if self.enabled {
-            <V as VisitAll>::visit_declaration(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_declaration(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_declaration_name(&mut self, node: &DeclarationName) {
+    fn fold_declaration_name(
+        &mut self,
+        node: DeclarationName,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationName {
         if self.enabled {
-            <V as VisitAll>::visit_declaration_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_declaration_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
+    fn fold_declaration_or_at_rule(
+        &mut self,
+        node: DeclarationOrAtRule,
+        __ast_path: &mut AstKindPath,
+    ) -> DeclarationOrAtRule {
         if self.enabled {
-            <V as VisitAll>::visit_declaration_or_at_rule(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_declaration_or_at_rule(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_delimiter(&mut self, node: &Delimiter) {
+    fn fold_delimiter(&mut self, node: Delimiter, __ast_path: &mut AstKindPath) -> Delimiter {
         if self.enabled {
-            <V as VisitAll>::visit_delimiter(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_delimiter(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
+    fn fold_delimiter_value(
+        &mut self,
+        node: DelimiterValue,
+        __ast_path: &mut AstKindPath,
+    ) -> DelimiterValue {
         if self.enabled {
-            <V as VisitAll>::visit_delimiter_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_delimiter_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_dimension(&mut self, node: &Dimension) {
+    fn fold_dimension(&mut self, node: Dimension, __ast_path: &mut AstKindPath) -> Dimension {
         if self.enabled {
-            <V as VisitAll>::visit_dimension(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_dimension(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_dimension_token(&mut self, node: &DimensionToken) {
+    fn fold_dimension_token(
+        &mut self,
+        node: DimensionToken,
+        __ast_path: &mut AstKindPath,
+    ) -> DimensionToken {
         if self.enabled {
-            <V as VisitAll>::visit_dimension_token(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_dimension_token(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
+    fn fold_document_prelude(
+        &mut self,
+        node: DocumentPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPrelude {
         if self.enabled {
-            <V as VisitAll>::visit_document_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_document_prelude(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_document_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
+    fn fold_document_prelude_matching_function(
+        &mut self,
+        node: DocumentPreludeMatchingFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> DocumentPreludeMatchingFunction {
         if self.enabled {
-            <V as VisitAll>::visit_document_prelude_matching_function(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_document_prelude_matching_function(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_document_prelude_matching_functions(
+    fn fold_document_prelude_matching_functions(
         &mut self,
-        node: &[DocumentPreludeMatchingFunction],
-    ) {
+        node: Vec<DocumentPreludeMatchingFunction>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<DocumentPreludeMatchingFunction> {
         if self.enabled {
-            <V as VisitAll>::visit_document_prelude_matching_functions(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_document_prelude_matching_functions(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_extension_name(&mut self, node: &ExtensionName) {
+    fn fold_extension_name(
+        &mut self,
+        node: ExtensionName,
+        __ast_path: &mut AstKindPath,
+    ) -> ExtensionName {
         if self.enabled {
-            <V as VisitAll>::visit_extension_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_extension_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_family_name(&mut self, node: &FamilyName) {
+    fn fold_family_name(&mut self, node: FamilyName, __ast_path: &mut AstKindPath) -> FamilyName {
         if self.enabled {
-            <V as VisitAll>::visit_family_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_family_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_family_names(&mut self, node: &[FamilyName]) {
+    fn fold_family_names(
+        &mut self,
+        node: Vec<FamilyName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<FamilyName> {
         if self.enabled {
-            <V as VisitAll>::visit_family_names(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_family_names(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_flex(&mut self, node: &Flex) {
+    fn fold_flex(&mut self, node: Flex, __ast_path: &mut AstKindPath) -> Flex {
         if self.enabled {
-            <V as VisitAll>::visit_flex(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_flex(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
+    fn fold_font_feature_values_prelude(
+        &mut self,
+        node: FontFeatureValuesPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> FontFeatureValuesPrelude {
         if self.enabled {
-            <V as VisitAll>::visit_font_feature_values_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_font_feature_values_prelude(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
+    fn fold_forgiving_complex_selector(
+        &mut self,
+        node: ForgivingComplexSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingComplexSelector {
         if self.enabled {
-            <V as VisitAll>::visit_forgiving_complex_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_forgiving_complex_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
+    fn fold_forgiving_complex_selectors(
+        &mut self,
+        node: Vec<ForgivingComplexSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingComplexSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_forgiving_complex_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_forgiving_complex_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
+    fn fold_forgiving_relative_selector(
+        &mut self,
+        node: ForgivingRelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelector {
         if self.enabled {
-            <V as VisitAll>::visit_forgiving_relative_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_forgiving_relative_selector(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
+    fn fold_forgiving_relative_selector_list(
+        &mut self,
+        node: ForgivingRelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingRelativeSelectorList {
         if self.enabled {
-            <V as VisitAll>::visit_forgiving_relative_selector_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_forgiving_relative_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
+    fn fold_forgiving_relative_selectors(
+        &mut self,
+        node: Vec<ForgivingRelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ForgivingRelativeSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_forgiving_relative_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_forgiving_relative_selectors(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
+    fn fold_forgiving_selector_list(
+        &mut self,
+        node: ForgivingSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> ForgivingSelectorList {
         if self.enabled {
-            <V as VisitAll>::visit_forgiving_selector_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_forgiving_selector_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_frequency(&mut self, node: &Frequency) {
+    fn fold_frequency(&mut self, node: Frequency, __ast_path: &mut AstKindPath) -> Frequency {
         if self.enabled {
-            <V as VisitAll>::visit_frequency(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_frequency(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
+    fn fold_frequency_percentage(
+        &mut self,
+        node: FrequencyPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> FrequencyPercentage {
         if self.enabled {
-            <V as VisitAll>::visit_frequency_percentage(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_frequency_percentage(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
         if self.enabled {
-            <V as VisitAll>::visit_function(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_function(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_function_name(&mut self, node: &FunctionName) {
+    fn fold_function_name(
+        &mut self,
+        node: FunctionName,
+        __ast_path: &mut AstKindPath,
+    ) -> FunctionName {
         if self.enabled {
-            <V as VisitAll>::visit_function_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_function_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
+    fn fold_general_enclosed(
+        &mut self,
+        node: GeneralEnclosed,
+        __ast_path: &mut AstKindPath,
+    ) -> GeneralEnclosed {
         if self.enabled {
-            <V as VisitAll>::visit_general_enclosed(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_general_enclosed(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_hex_color(&mut self, node: &HexColor) {
+    fn fold_hex_color(&mut self, node: HexColor, __ast_path: &mut AstKindPath) -> HexColor {
         if self.enabled {
-            <V as VisitAll>::visit_hex_color(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_hex_color(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_hue(&mut self, node: &Hue) {
+    fn fold_hue(&mut self, node: Hue, __ast_path: &mut AstKindPath) -> Hue {
         if self.enabled {
-            <V as VisitAll>::visit_hue(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_hue(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_id_selector(&mut self, node: &IdSelector) {
+    fn fold_id_selector(&mut self, node: IdSelector, __ast_path: &mut AstKindPath) -> IdSelector {
         if self.enabled {
-            <V as VisitAll>::visit_id_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_id_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
         if self.enabled {
-            <V as VisitAll>::visit_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_idents(&mut self, node: &[Ident]) {
+    fn fold_idents(&mut self, node: Vec<Ident>, __ast_path: &mut AstKindPath) -> Vec<Ident> {
         if self.enabled {
-            <V as VisitAll>::visit_idents(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_idents(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_conditions(&mut self, node: &ImportConditions) {
+    fn fold_import_conditions(
+        &mut self,
+        node: ImportConditions,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportConditions {
         if self.enabled {
-            <V as VisitAll>::visit_import_conditions(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_conditions(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_href(&mut self, node: &ImportHref) {
+    fn fold_import_href(&mut self, node: ImportHref, __ast_path: &mut AstKindPath) -> ImportHref {
         if self.enabled {
-            <V as VisitAll>::visit_import_href(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_href(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
+    fn fold_import_layer_name(
+        &mut self,
+        node: ImportLayerName,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportLayerName {
         if self.enabled {
-            <V as VisitAll>::visit_import_layer_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_layer_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_prelude(&mut self, node: &ImportPrelude) {
+    fn fold_import_prelude(
+        &mut self,
+        node: ImportPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPrelude {
         if self.enabled {
-            <V as VisitAll>::visit_import_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_prelude(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_important_flag(&mut self, node: &ImportantFlag) {
+    fn fold_important_flag(
+        &mut self,
+        node: ImportantFlag,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportantFlag {
         if self.enabled {
-            <V as VisitAll>::visit_important_flag(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_important_flag(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_integer(&mut self, node: &Integer) {
+    fn fold_integer(&mut self, node: Integer, __ast_path: &mut AstKindPath) -> Integer {
         if self.enabled {
-            <V as VisitAll>::visit_integer(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_integer(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
+    fn fold_keyframe_block(
+        &mut self,
+        node: KeyframeBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeBlock {
         if self.enabled {
-            <V as VisitAll>::visit_keyframe_block(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_keyframe_block(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
+    fn fold_keyframe_selector(
+        &mut self,
+        node: KeyframeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframeSelector {
         if self.enabled {
-            <V as VisitAll>::visit_keyframe_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_keyframe_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
+    fn fold_keyframe_selectors(
+        &mut self,
+        node: Vec<KeyframeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<KeyframeSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_keyframe_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_keyframe_selectors(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_keyframes_name(&mut self, node: &KeyframesName) {
+    fn fold_keyframes_name(
+        &mut self,
+        node: KeyframesName,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesName {
         if self.enabled {
-            <V as VisitAll>::visit_keyframes_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_keyframes_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
+    fn fold_keyframes_pseudo_function(
+        &mut self,
+        node: KeyframesPseudoFunction,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoFunction {
         if self.enabled {
-            <V as VisitAll>::visit_keyframes_pseudo_function(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_keyframes_pseudo_function(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
+    fn fold_keyframes_pseudo_prefix(
+        &mut self,
+        node: KeyframesPseudoPrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyframesPseudoPrefix {
         if self.enabled {
-            <V as VisitAll>::visit_keyframes_pseudo_prefix(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_keyframes_pseudo_prefix(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_layer_name(&mut self, node: &LayerName) {
+    fn fold_layer_name(&mut self, node: LayerName, __ast_path: &mut AstKindPath) -> LayerName {
         if self.enabled {
-            <V as VisitAll>::visit_layer_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_layer_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_layer_name_list(&mut self, node: &LayerNameList) {
+    fn fold_layer_name_list(
+        &mut self,
+        node: LayerNameList,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerNameList {
         if self.enabled {
-            <V as VisitAll>::visit_layer_name_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_layer_name_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_layer_names(&mut self, node: &[LayerName]) {
+    fn fold_layer_names(
+        &mut self,
+        node: Vec<LayerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<LayerName> {
         if self.enabled {
-            <V as VisitAll>::visit_layer_names(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_layer_names(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
+    fn fold_layer_prelude(
+        &mut self,
+        node: LayerPrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> LayerPrelude {
         if self.enabled {
-            <V as VisitAll>::visit_layer_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_layer_prelude(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_length(&mut self, node: &Length) {
+    fn fold_length(&mut self, node: Length, __ast_path: &mut AstKindPath) -> Length {
         if self.enabled {
-            <V as VisitAll>::visit_length(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_length(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_length_percentage(&mut self, node: &LengthPercentage) {
+    fn fold_length_percentage(
+        &mut self,
+        node: LengthPercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> LengthPercentage {
         if self.enabled {
-            <V as VisitAll>::visit_length_percentage(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_length_percentage(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
+    fn fold_list_of_component_values(
+        &mut self,
+        node: ListOfComponentValues,
+        __ast_path: &mut AstKindPath,
+    ) -> ListOfComponentValues {
         if self.enabled {
-            <V as VisitAll>::visit_list_of_component_values(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_list_of_component_values(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_and(&mut self, node: &MediaAnd) {
+    fn fold_media_and(&mut self, node: MediaAnd, __ast_path: &mut AstKindPath) -> MediaAnd {
         if self.enabled {
-            <V as VisitAll>::visit_media_and(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_and(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_condition(&mut self, node: &MediaCondition) {
+    fn fold_media_condition(
+        &mut self,
+        node: MediaCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaCondition {
         if self.enabled {
-            <V as VisitAll>::visit_media_condition(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_condition(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
+    fn fold_media_condition_all_type(
+        &mut self,
+        node: MediaConditionAllType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionAllType {
         if self.enabled {
-            <V as VisitAll>::visit_media_condition_all_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_condition_all_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
+    fn fold_media_condition_all_types(
+        &mut self,
+        node: Vec<MediaConditionAllType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionAllType> {
         if self.enabled {
-            <V as VisitAll>::visit_media_condition_all_types(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_condition_all_types(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
+    fn fold_media_condition_type(
+        &mut self,
+        node: MediaConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionType {
         if self.enabled {
-            <V as VisitAll>::visit_media_condition_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_condition_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
+    fn fold_media_condition_without_or(
+        &mut self,
+        node: MediaConditionWithoutOr,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOr {
         if self.enabled {
-            <V as VisitAll>::visit_media_condition_without_or(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_condition_without_or(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_condition_without_or_type(&mut self, node: &MediaConditionWithoutOrType) {
+    fn fold_media_condition_without_or_type(
+        &mut self,
+        node: MediaConditionWithoutOrType,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaConditionWithoutOrType {
         if self.enabled {
-            <V as VisitAll>::visit_media_condition_without_or_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_condition_without_or_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_condition_without_or_types(&mut self, node: &[MediaConditionWithoutOrType]) {
+    fn fold_media_condition_without_or_types(
+        &mut self,
+        node: Vec<MediaConditionWithoutOrType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaConditionWithoutOrType> {
         if self.enabled {
-            <V as VisitAll>::visit_media_condition_without_or_types(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_condition_without_or_types(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature(&mut self, node: &MediaFeature) {
+    fn fold_media_feature(
+        &mut self,
+        node: MediaFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeature {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
+    fn fold_media_feature_boolean(
+        &mut self,
+        node: MediaFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureBoolean {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature_boolean(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature_boolean(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
+    fn fold_media_feature_name(
+        &mut self,
+        node: MediaFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureName {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
+    fn fold_media_feature_plain(
+        &mut self,
+        node: MediaFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeaturePlain {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature_plain(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature_plain(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
+    fn fold_media_feature_range(
+        &mut self,
+        node: MediaFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRange {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature_range(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature_range(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
+    fn fold_media_feature_range_comparison(
+        &mut self,
+        node: MediaFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeComparison {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature_range_comparison(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature_range_comparison(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
+    fn fold_media_feature_range_interval(
+        &mut self,
+        node: MediaFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureRangeInterval {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature_range_interval(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature_range_interval(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
+    fn fold_media_feature_value(
+        &mut self,
+        node: MediaFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaFeatureValue {
         if self.enabled {
-            <V as VisitAll>::visit_media_feature_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_feature_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_in_parens(&mut self, node: &MediaInParens) {
+    fn fold_media_in_parens(
+        &mut self,
+        node: MediaInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaInParens {
         if self.enabled {
-            <V as VisitAll>::visit_media_in_parens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_in_parens(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_not(&mut self, node: &MediaNot) {
+    fn fold_media_not(&mut self, node: MediaNot, __ast_path: &mut AstKindPath) -> MediaNot {
         if self.enabled {
-            <V as VisitAll>::visit_media_not(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_not(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_or(&mut self, node: &MediaOr) {
+    fn fold_media_or(&mut self, node: MediaOr, __ast_path: &mut AstKindPath) -> MediaOr {
         if self.enabled {
-            <V as VisitAll>::visit_media_or(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_or(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_query(&mut self, node: &MediaQuery) {
+    fn fold_media_query(&mut self, node: MediaQuery, __ast_path: &mut AstKindPath) -> MediaQuery {
         if self.enabled {
-            <V as VisitAll>::visit_media_query(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_query(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_query_list(&mut self, node: &MediaQueryList) {
+    fn fold_media_query_list(
+        &mut self,
+        node: MediaQueryList,
+        __ast_path: &mut AstKindPath,
+    ) -> MediaQueryList {
         if self.enabled {
-            <V as VisitAll>::visit_media_query_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_query_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_querys(&mut self, node: &[MediaQuery]) {
+    fn fold_media_querys(
+        &mut self,
+        node: Vec<MediaQuery>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<MediaQuery> {
         if self.enabled {
-            <V as VisitAll>::visit_media_querys(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_querys(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_media_type(&mut self, node: &MediaType) {
+    fn fold_media_type(&mut self, node: MediaType, __ast_path: &mut AstKindPath) -> MediaType {
         if self.enabled {
-            <V as VisitAll>::visit_media_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_media_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_named_namespace(&mut self, node: &NamedNamespace) {
+    fn fold_named_namespace(
+        &mut self,
+        node: NamedNamespace,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedNamespace {
         if self.enabled {
-            <V as VisitAll>::visit_named_namespace(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_named_namespace(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
+    fn fold_namespace(&mut self, node: Namespace, __ast_path: &mut AstKindPath) -> Namespace {
         if self.enabled {
-            <V as VisitAll>::visit_namespace(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_namespace(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
+    fn fold_namespace_prefix(
+        &mut self,
+        node: NamespacePrefix,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrefix {
         if self.enabled {
-            <V as VisitAll>::visit_namespace_prefix(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_namespace_prefix(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
+    fn fold_namespace_prelude(
+        &mut self,
+        node: NamespacePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePrelude {
         if self.enabled {
-            <V as VisitAll>::visit_namespace_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_namespace_prelude(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
+    fn fold_namespace_prelude_uri(
+        &mut self,
+        node: NamespacePreludeUri,
+        __ast_path: &mut AstKindPath,
+    ) -> NamespacePreludeUri {
         if self.enabled {
-            <V as VisitAll>::visit_namespace_prelude_uri(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_namespace_prelude_uri(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_nesting_selector(&mut self, node: &NestingSelector) {
+    fn fold_nesting_selector(
+        &mut self,
+        node: NestingSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> NestingSelector {
         if self.enabled {
-            <V as VisitAll>::visit_nesting_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_nesting_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
         if self.enabled {
-            <V as VisitAll>::visit_number(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_number(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_number_type(&mut self, node: &NumberType) {
+    fn fold_number_type(&mut self, node: NumberType, __ast_path: &mut AstKindPath) -> NumberType {
         if self.enabled {
-            <V as VisitAll>::visit_number_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_number_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>) {
+    fn fold_opt_at_rule_prelude(
+        &mut self,
+        node: Option<Box<AtRulePrelude>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<AtRulePrelude>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_at_rule_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_at_rule_prelude(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_atom(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_atom(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_matcher(&mut self, node: &Option<AttributeSelectorMatcher>) {
+    fn fold_opt_attribute_selector_matcher(
+        &mut self,
+        node: Option<AttributeSelectorMatcher>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorMatcher> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_attribute_selector_matcher(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_attribute_selector_matcher(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_modifier(&mut self, node: &Option<AttributeSelectorModifier>) {
+    fn fold_opt_attribute_selector_modifier(
+        &mut self,
+        node: Option<AttributeSelectorModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorModifier> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_attribute_selector_modifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_attribute_selector_modifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_attribute_selector_value(&mut self, node: &Option<AttributeSelectorValue>) {
+    fn fold_opt_attribute_selector_value(
+        &mut self,
+        node: Option<AttributeSelectorValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<AttributeSelectorValue> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_attribute_selector_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_attribute_selector_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
+    fn fold_opt_combinator(
+        &mut self,
+        node: Option<Combinator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Combinator> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_combinator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_combinator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_container_name(&mut self, node: &Option<ContainerName>) {
+    fn fold_opt_container_name(
+        &mut self,
+        node: Option<ContainerName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ContainerName> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_container_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_container_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_forgiving_selector_list(&mut self, node: &Option<ForgivingSelectorList>) {
+    fn fold_opt_forgiving_selector_list(
+        &mut self,
+        node: Option<ForgivingSelectorList>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ForgivingSelectorList> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_forgiving_selector_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_forgiving_selector_list(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_function(&mut self, node: &Option<Box<Function>>) {
+    fn fold_opt_function(
+        &mut self,
+        node: Option<Box<Function>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Function>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_function(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_function(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>) {
+    fn fold_opt_import_conditions(
+        &mut self,
+        node: Option<Box<ImportConditions>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportConditions>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_import_conditions(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_import_conditions(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>) {
+    fn fold_opt_import_layer_name(
+        &mut self,
+        node: Option<Box<ImportLayerName>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ImportLayerName>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_import_layer_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_import_layer_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>) {
+    fn fold_opt_important_flag(
+        &mut self,
+        node: Option<ImportantFlag>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ImportantFlag> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_important_flag(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_important_flag(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_media_condition_type(&mut self, node: &Option<Box<MediaConditionType>>) {
+    fn fold_opt_media_condition_type(
+        &mut self,
+        node: Option<Box<MediaConditionType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaConditionType>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_media_condition_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_media_condition_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>) {
+    fn fold_opt_media_query_list(
+        &mut self,
+        node: Option<Box<MediaQueryList>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<MediaQueryList>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_media_query_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_media_query_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_media_type(&mut self, node: &Option<MediaType>) {
+    fn fold_opt_media_type(
+        &mut self,
+        node: Option<MediaType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<MediaType> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_media_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_media_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
+    fn fold_opt_namespace(
+        &mut self,
+        node: Option<Namespace>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Namespace> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_namespace(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_namespace(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_namespace_prefix(&mut self, node: &Option<NamespacePrefix>) {
+    fn fold_opt_namespace_prefix(
+        &mut self,
+        node: Option<NamespacePrefix>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NamespacePrefix> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_namespace_prefix(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_namespace_prefix(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_nesting_selector(&mut self, node: &Option<NestingSelector>) {
+    fn fold_opt_nesting_selector(
+        &mut self,
+        node: Option<NestingSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<NestingSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_nesting_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_nesting_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_number(&mut self, node: &Option<Number>) {
+    fn fold_opt_number(
+        &mut self,
+        node: Option<Number>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Number> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_number(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_number(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_page_selector_pseudos(&mut self, node: &Option<Vec<PageSelectorPseudo>>) {
+    fn fold_opt_page_selector_pseudos(
+        &mut self,
+        node: Option<Vec<PageSelectorPseudo>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PageSelectorPseudo>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_page_selector_pseudos(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_page_selector_pseudos(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_page_selector_type(&mut self, node: &Option<PageSelectorType>) {
+    fn fold_opt_page_selector_type(
+        &mut self,
+        node: Option<PageSelectorType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<PageSelectorType> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_page_selector_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_page_selector_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_pseudo_class_selector_childrens(
+    fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
-        node: &Option<Vec<PseudoClassSelectorChildren>>,
-    ) {
+        node: Option<Vec<PseudoClassSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoClassSelectorChildren>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_pseudo_class_selector_childrens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_pseudo_element_selector_childrens(
+    fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
-        node: &Option<Vec<PseudoElementSelectorChildren>>,
-    ) {
+        node: Option<Vec<PseudoElementSelectorChildren>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<PseudoElementSelectorChildren>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_pseudo_element_selector_childrens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>) {
+    fn fold_opt_simple_block(
+        &mut self,
+        node: Option<SimpleBlock>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<SimpleBlock> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_simple_block(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_simple_block(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>) {
+    fn fold_opt_type_selector(
+        &mut self,
+        node: Option<Box<TypeSelector>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TypeSelector>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_type_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_type_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>) {
+    fn fold_opt_url_modifiers(
+        &mut self,
+        node: Option<Vec<UrlModifier>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<UrlModifier>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_url_modifiers(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_url_modifiers(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_url_value(&mut self, node: &Option<Box<UrlValue>>) {
+    fn fold_opt_url_value(
+        &mut self,
+        node: Option<Box<UrlValue>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<UrlValue>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_url_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_url_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_page_selector(&mut self, node: &PageSelector) {
+    fn fold_page_selector(
+        &mut self,
+        node: PageSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelector {
         if self.enabled {
-            <V as VisitAll>::visit_page_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_page_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
+    fn fold_page_selector_list(
+        &mut self,
+        node: PageSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorList {
         if self.enabled {
-            <V as VisitAll>::visit_page_selector_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_page_selector_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
+    fn fold_page_selector_pseudo(
+        &mut self,
+        node: PageSelectorPseudo,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorPseudo {
         if self.enabled {
-            <V as VisitAll>::visit_page_selector_pseudo(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_page_selector_pseudo(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
+    fn fold_page_selector_pseudos(
+        &mut self,
+        node: Vec<PageSelectorPseudo>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelectorPseudo> {
         if self.enabled {
-            <V as VisitAll>::visit_page_selector_pseudos(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_page_selector_pseudos(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
+    fn fold_page_selector_type(
+        &mut self,
+        node: PageSelectorType,
+        __ast_path: &mut AstKindPath,
+    ) -> PageSelectorType {
         if self.enabled {
-            <V as VisitAll>::visit_page_selector_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_page_selector_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_page_selectors(&mut self, node: &[PageSelector]) {
+    fn fold_page_selectors(
+        &mut self,
+        node: Vec<PageSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PageSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_page_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_page_selectors(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_percentage(&mut self, node: &Percentage) {
+    fn fold_percentage(&mut self, node: Percentage, __ast_path: &mut AstKindPath) -> Percentage {
         if self.enabled {
-            <V as VisitAll>::visit_percentage(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_percentage(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
+    fn fold_pseudo_class_selector(
+        &mut self,
+        node: PseudoClassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelector {
         if self.enabled {
-            <V as VisitAll>::visit_pseudo_class_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pseudo_class_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
+    fn fold_pseudo_class_selector_children(
+        &mut self,
+        node: PseudoClassSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoClassSelectorChildren {
         if self.enabled {
-            <V as VisitAll>::visit_pseudo_class_selector_children(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pseudo_class_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
+    fn fold_pseudo_class_selector_childrens(
+        &mut self,
+        node: Vec<PseudoClassSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoClassSelectorChildren> {
         if self.enabled {
-            <V as VisitAll>::visit_pseudo_class_selector_childrens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pseudo_class_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
+    fn fold_pseudo_element_selector(
+        &mut self,
+        node: PseudoElementSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelector {
         if self.enabled {
-            <V as VisitAll>::visit_pseudo_element_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pseudo_element_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
+    fn fold_pseudo_element_selector_children(
+        &mut self,
+        node: PseudoElementSelectorChildren,
+        __ast_path: &mut AstKindPath,
+    ) -> PseudoElementSelectorChildren {
         if self.enabled {
-            <V as VisitAll>::visit_pseudo_element_selector_children(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pseudo_element_selector_children(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
+    fn fold_pseudo_element_selector_childrens(
+        &mut self,
+        node: Vec<PseudoElementSelectorChildren>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PseudoElementSelectorChildren> {
         if self.enabled {
-            <V as VisitAll>::visit_pseudo_element_selector_childrens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pseudo_element_selector_childrens(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
+    fn fold_qualified_rule(
+        &mut self,
+        node: QualifiedRule,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRule {
         if self.enabled {
-            <V as VisitAll>::visit_qualified_rule(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_qualified_rule(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
+    fn fold_qualified_rule_prelude(
+        &mut self,
+        node: QualifiedRulePrelude,
+        __ast_path: &mut AstKindPath,
+    ) -> QualifiedRulePrelude {
         if self.enabled {
-            <V as VisitAll>::visit_qualified_rule_prelude(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_qualified_rule_prelude(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_query_in_parens(&mut self, node: &QueryInParens) {
+    fn fold_query_in_parens(
+        &mut self,
+        node: QueryInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> QueryInParens {
         if self.enabled {
-            <V as VisitAll>::visit_query_in_parens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_query_in_parens(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ratio(&mut self, node: &Ratio) {
+    fn fold_ratio(&mut self, node: Ratio, __ast_path: &mut AstKindPath) -> Ratio {
         if self.enabled {
-            <V as VisitAll>::visit_ratio(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ratio(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_relative_selector(&mut self, node: &RelativeSelector) {
+    fn fold_relative_selector(
+        &mut self,
+        node: RelativeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelector {
         if self.enabled {
-            <V as VisitAll>::visit_relative_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_relative_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
+    fn fold_relative_selector_list(
+        &mut self,
+        node: RelativeSelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> RelativeSelectorList {
         if self.enabled {
-            <V as VisitAll>::visit_relative_selector_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_relative_selector_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
+    fn fold_relative_selectors(
+        &mut self,
+        node: Vec<RelativeSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<RelativeSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_relative_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_relative_selectors(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_resolution(&mut self, node: &Resolution) {
+    fn fold_resolution(&mut self, node: Resolution, __ast_path: &mut AstKindPath) -> Resolution {
         if self.enabled {
-            <V as VisitAll>::visit_resolution(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_resolution(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_rule(&mut self, node: &Rule) {
+    fn fold_rule(&mut self, node: Rule, __ast_path: &mut AstKindPath) -> Rule {
         if self.enabled {
-            <V as VisitAll>::visit_rule(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_rule(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_rules(&mut self, node: &[Rule]) {
+    fn fold_rules(&mut self, node: Vec<Rule>, __ast_path: &mut AstKindPath) -> Vec<Rule> {
         if self.enabled {
-            <V as VisitAll>::visit_rules(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_rules(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_scope_range(&mut self, node: &ScopeRange) {
+    fn fold_scope_range(&mut self, node: ScopeRange, __ast_path: &mut AstKindPath) -> ScopeRange {
         if self.enabled {
-            <V as VisitAll>::visit_scope_range(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_scope_range(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_selector_list(&mut self, node: &SelectorList) {
+    fn fold_selector_list(
+        &mut self,
+        node: SelectorList,
+        __ast_path: &mut AstKindPath,
+    ) -> SelectorList {
         if self.enabled {
-            <V as VisitAll>::visit_selector_list(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_selector_list(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
+    fn fold_sequence_of_custom_idents(
+        &mut self,
+        node: SequenceOfCustomIdents,
+        __ast_path: &mut AstKindPath,
+    ) -> SequenceOfCustomIdents {
         if self.enabled {
-            <V as VisitAll>::visit_sequence_of_custom_idents(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_sequence_of_custom_idents(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_simple_block(&mut self, node: &SimpleBlock) {
+    fn fold_simple_block(
+        &mut self,
+        node: SimpleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleBlock {
         if self.enabled {
-            <V as VisitAll>::visit_simple_block(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_simple_block(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature(&mut self, node: &SizeFeature) {
+    fn fold_size_feature(
+        &mut self,
+        node: SizeFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeature {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
+    fn fold_size_feature_boolean(
+        &mut self,
+        node: SizeFeatureBoolean,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureBoolean {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature_boolean(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature_boolean(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
+    fn fold_size_feature_name(
+        &mut self,
+        node: SizeFeatureName,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureName {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
+    fn fold_size_feature_plain(
+        &mut self,
+        node: SizeFeaturePlain,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeaturePlain {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature_plain(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature_plain(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
+    fn fold_size_feature_range(
+        &mut self,
+        node: SizeFeatureRange,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRange {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature_range(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature_range(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
+    fn fold_size_feature_range_comparison(
+        &mut self,
+        node: SizeFeatureRangeComparison,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeComparison {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature_range_comparison(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature_range_comparison(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
+    fn fold_size_feature_range_interval(
+        &mut self,
+        node: SizeFeatureRangeInterval,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureRangeInterval {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature_range_interval(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature_range_interval(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
+    fn fold_size_feature_value(
+        &mut self,
+        node: SizeFeatureValue,
+        __ast_path: &mut AstKindPath,
+    ) -> SizeFeatureValue {
         if self.enabled {
-            <V as VisitAll>::visit_size_feature_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_size_feature_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
         if self.enabled {
-            <V as VisitAll>::visit_span(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_span(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
         if self.enabled {
-            <V as VisitAll>::visit_str(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_str(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_style_block(&mut self, node: &StyleBlock) {
+    fn fold_style_block(&mut self, node: StyleBlock, __ast_path: &mut AstKindPath) -> StyleBlock {
         if self.enabled {
-            <V as VisitAll>::visit_style_block(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_style_block(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_stylesheet(&mut self, node: &Stylesheet) {
+    fn fold_stylesheet(&mut self, node: Stylesheet, __ast_path: &mut AstKindPath) -> Stylesheet {
         if self.enabled {
-            <V as VisitAll>::visit_stylesheet(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_stylesheet(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
+    fn fold_subclass_selector(
+        &mut self,
+        node: SubclassSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> SubclassSelector {
         if self.enabled {
-            <V as VisitAll>::visit_subclass_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_subclass_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
+    fn fold_subclass_selectors(
+        &mut self,
+        node: Vec<SubclassSelector>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SubclassSelector> {
         if self.enabled {
-            <V as VisitAll>::visit_subclass_selectors(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_subclass_selectors(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_and(&mut self, node: &SupportsAnd) {
+    fn fold_supports_and(
+        &mut self,
+        node: SupportsAnd,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsAnd {
         if self.enabled {
-            <V as VisitAll>::visit_supports_and(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_and(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_condition(&mut self, node: &SupportsCondition) {
+    fn fold_supports_condition(
+        &mut self,
+        node: SupportsCondition,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsCondition {
         if self.enabled {
-            <V as VisitAll>::visit_supports_condition(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_condition(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
+    fn fold_supports_condition_type(
+        &mut self,
+        node: SupportsConditionType,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsConditionType {
         if self.enabled {
-            <V as VisitAll>::visit_supports_condition_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_condition_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
+    fn fold_supports_condition_types(
+        &mut self,
+        node: Vec<SupportsConditionType>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SupportsConditionType> {
         if self.enabled {
-            <V as VisitAll>::visit_supports_condition_types(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_condition_types(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_feature(&mut self, node: &SupportsFeature) {
+    fn fold_supports_feature(
+        &mut self,
+        node: SupportsFeature,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsFeature {
         if self.enabled {
-            <V as VisitAll>::visit_supports_feature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_feature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
+    fn fold_supports_in_parens(
+        &mut self,
+        node: SupportsInParens,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsInParens {
         if self.enabled {
-            <V as VisitAll>::visit_supports_in_parens(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_in_parens(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_not(&mut self, node: &SupportsNot) {
+    fn fold_supports_not(
+        &mut self,
+        node: SupportsNot,
+        __ast_path: &mut AstKindPath,
+    ) -> SupportsNot {
         if self.enabled {
-            <V as VisitAll>::visit_supports_not(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_not(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_supports_or(&mut self, node: &SupportsOr) {
+    fn fold_supports_or(&mut self, node: SupportsOr, __ast_path: &mut AstKindPath) -> SupportsOr {
         if self.enabled {
-            <V as VisitAll>::visit_supports_or(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_supports_or(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
+    fn fold_tag_name_selector(
+        &mut self,
+        node: TagNameSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TagNameSelector {
         if self.enabled {
-            <V as VisitAll>::visit_tag_name_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_tag_name_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_time(&mut self, node: &Time) {
+    fn fold_time(&mut self, node: Time, __ast_path: &mut AstKindPath) -> Time {
         if self.enabled {
-            <V as VisitAll>::visit_time(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_time(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_time_percentage(&mut self, node: &TimePercentage) {
+    fn fold_time_percentage(
+        &mut self,
+        node: TimePercentage,
+        __ast_path: &mut AstKindPath,
+    ) -> TimePercentage {
         if self.enabled {
-            <V as VisitAll>::visit_time_percentage(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_time_percentage(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_token(&mut self, node: &Token) {
+    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token {
         if self.enabled {
-            <V as VisitAll>::visit_token(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_token(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
+    fn fold_token_and_span(
+        &mut self,
+        node: TokenAndSpan,
+        __ast_path: &mut AstKindPath,
+    ) -> TokenAndSpan {
         if self.enabled {
-            <V as VisitAll>::visit_token_and_span(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_token_and_span(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_type_selector(&mut self, node: &TypeSelector) {
+    fn fold_type_selector(
+        &mut self,
+        node: TypeSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> TypeSelector {
         if self.enabled {
-            <V as VisitAll>::visit_type_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_type_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_unicode_range(&mut self, node: &UnicodeRange) {
+    fn fold_unicode_range(
+        &mut self,
+        node: UnicodeRange,
+        __ast_path: &mut AstKindPath,
+    ) -> UnicodeRange {
         if self.enabled {
-            <V as VisitAll>::visit_unicode_range(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_unicode_range(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_universal_selector(&mut self, node: &UniversalSelector) {
+    fn fold_universal_selector(
+        &mut self,
+        node: UniversalSelector,
+        __ast_path: &mut AstKindPath,
+    ) -> UniversalSelector {
         if self.enabled {
-            <V as VisitAll>::visit_universal_selector(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_universal_selector(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
+    fn fold_unknown_dimension(
+        &mut self,
+        node: UnknownDimension,
+        __ast_path: &mut AstKindPath,
+    ) -> UnknownDimension {
         if self.enabled {
-            <V as VisitAll>::visit_unknown_dimension(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_unknown_dimension(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_url(&mut self, node: &Url) {
+    fn fold_url(&mut self, node: Url, __ast_path: &mut AstKindPath) -> Url {
         if self.enabled {
-            <V as VisitAll>::visit_url(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_url(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
+    fn fold_url_key_value(
+        &mut self,
+        node: UrlKeyValue,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlKeyValue {
         if self.enabled {
-            <V as VisitAll>::visit_url_key_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_url_key_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_url_modifier(&mut self, node: &UrlModifier) {
+    fn fold_url_modifier(
+        &mut self,
+        node: UrlModifier,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlModifier {
         if self.enabled {
-            <V as VisitAll>::visit_url_modifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_url_modifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
+    fn fold_url_modifiers(
+        &mut self,
+        node: Vec<UrlModifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<UrlModifier> {
         if self.enabled {
-            <V as VisitAll>::visit_url_modifiers(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_url_modifiers(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_url_value(&mut self, node: &UrlValue) {
+    fn fold_url_value(&mut self, node: UrlValue, __ast_path: &mut AstKindPath) -> UrlValue {
         if self.enabled {
-            <V as VisitAll>::visit_url_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_url_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
+    fn fold_url_value_raw(
+        &mut self,
+        node: UrlValueRaw,
+        __ast_path: &mut AstKindPath,
+    ) -> UrlValueRaw {
         if self.enabled {
-            <V as VisitAll>::visit_url_value_raw(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_url_value_raw(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_wq_name(&mut self, node: &WqName) {
+    fn fold_wq_name(&mut self, node: WqName, __ast_path: &mut AstKindPath) -> WqName {
         if self.enabled {
-            <V as VisitAll>::visit_wq_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_wq_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitAllWith<V: ?Sized + VisitAll> {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait FoldWithAstPath<V: ?Sized + FoldAstPath> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with(&self, visitor: &mut V);
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with(&self, visitor: &mut V);
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AbsoluteColorBase {
-    #[doc = "Calls [VisitAll`::visit_absolute_color_base`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_absolute_color_base(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AbsoluteColorBase {
+    #[doc = "Calls [FoldAstPath`::fold_absolute_color_base`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_absolute_color_base(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AbsoluteColorBase::HexColor { 0: _field_0 } => {
-                <HexColor as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
+                    self::fields::AbsoluteColorBaseField::HexColor,
+                ));
+                let _field_0 = <HexColor as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AbsoluteColorBase::HexColor { 0: _field_0 }
             }
             AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
+                    self::fields::AbsoluteColorBaseField::NamedColorOrTransparent,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AbsoluteColorBase::NamedColorOrTransparent { 0: _field_0 }
             }
             AbsoluteColorBase::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AbsoluteColorBase(
+                    self::fields::AbsoluteColorBaseField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AbsoluteColorBase::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AlphaValue {
-    #[doc = "Calls [VisitAll`::visit_alpha_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_alpha_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AlphaValue {
+    #[doc = "Calls [FoldAstPath`::fold_alpha_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_alpha_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AlphaValue::Number { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
+                    self::fields::AlphaValueField::Number,
+                ));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AlphaValue::Number { 0: _field_0 }
             }
             AlphaValue::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AlphaValue(
+                    self::fields::AlphaValueField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AlphaValue::Percentage { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AnPlusB {
-    #[doc = "Calls [VisitAll`::visit_an_plus_b`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_an_plus_b(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnPlusB {
+    #[doc = "Calls [FoldAstPath`::fold_an_plus_b`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_an_plus_b(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AnPlusB::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::AnPlusB(self::fields::AnPlusBField::Ident));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AnPlusB::Ident { 0: _field_0 }
             }
             AnPlusB::AnPlusBNotation { 0: _field_0 } => {
-                <AnPlusBNotation as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusB(
+                    self::fields::AnPlusBField::AnPlusBNotation,
+                ));
+                let _field_0 = <AnPlusBNotation as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AnPlusB::AnPlusBNotation { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AnPlusBNotation {
-    #[doc = "Calls [VisitAll`::visit_an_plus_b_notation`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_an_plus_b_notation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnPlusBNotation {
+    #[doc = "Calls [FoldAstPath`::fold_an_plus_b_notation`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_an_plus_b_notation(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AnPlusBNotation {
                 span,
@@ -117372,81 +98518,160 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for AnPlusBNotation {
                 b,
                 b_raw,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
+                        self::fields::AnPlusBNotationField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(a_raw, visitor)
+                let a_raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
+                        self::fields::AnPlusBNotationField::ARaw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        a_raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(b_raw, visitor)
+                let b_raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnPlusBNotation(
+                        self::fields::AnPlusBNotationField::BRaw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        b_raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AnPlusBNotation {
+                    span,
+                    a,
+                    a_raw,
+                    b,
+                    b_raw,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Angle {
-    #[doc = "Calls [VisitAll`::visit_angle`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_angle(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Angle {
+    #[doc = "Calls [FoldAstPath`::fold_angle`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_angle(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Angle { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Angle(self::fields::AngleField::Value));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Angle(self::fields::AngleField::Unit));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Angle { span, value, unit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AnglePercentage {
-    #[doc = "Calls [VisitAll`::visit_angle_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_angle_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnglePercentage {
+    #[doc = "Calls [FoldAstPath`::fold_angle_percentage`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_angle_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AnglePercentage::Angle { 0: _field_0 } => {
-                <Angle as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
+                    self::fields::AnglePercentageField::Angle,
+                ));
+                let _field_0 = <Angle as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AnglePercentage::Angle { 0: _field_0 }
             }
             AnglePercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AnglePercentage(
+                    self::fields::AnglePercentageField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AnglePercentage::Percentage { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AnyNamespace {
-    #[doc = "Calls [VisitAll`::visit_any_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_any_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AnyNamespace {
+    #[doc = "Calls [FoldAstPath`::fold_any_namespace`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_any_namespace(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AnyNamespace { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AnyNamespace(
+                        self::fields::AnyNamespaceField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AnyNamespace { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AtRule {
-    #[doc = "Calls [VisitAll`::visit_at_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_at_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRule {
+    #[doc = "Calls [FoldAstPath`::fold_at_rule`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_at_rule(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AtRule {
                 span,
@@ -117454,114 +98679,318 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for AtRule {
                 prelude,
                 block,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <AtRuleName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Name));
+                    <AtRuleName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<AtRulePrelude>> as VisitAllWith<V>>::visit_with(prelude, visitor)
+                let prelude = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Prelude));
+                    <Option<Box<AtRulePrelude>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<SimpleBlock> as VisitAllWith<V>>::visit_with(block, visitor)
+                let block = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AtRule(self::fields::AtRuleField::Block));
+                    <Option<SimpleBlock> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AtRule {
+                    span,
+                    name,
+                    prelude,
+                    block,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AtRuleName {
-    #[doc = "Calls [VisitAll`::visit_at_rule_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_at_rule_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRuleName {
+    #[doc = "Calls [FoldAstPath`::fold_at_rule_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_at_rule_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AtRuleName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
+                    self::fields::AtRuleNameField::DashedIdent,
+                ));
+                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRuleName::DashedIdent { 0: _field_0 }
             }
             AtRuleName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRuleName(
+                    self::fields::AtRuleNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRuleName::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AtRulePrelude {
-    #[doc = "Calls [VisitAll`::visit_at_rule_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_at_rule_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AtRulePrelude {
+    #[doc = "Calls [FoldAstPath`::fold_at_rule_prelude`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_at_rule_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AtRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ListOfComponentValues,
+                ));
+                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::ListOfComponentValues { 0: _field_0 }
             }
             AtRulePrelude::CharsetPrelude { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::CharsetPrelude,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::CharsetPrelude { 0: _field_0 }
             }
             AtRulePrelude::PropertyPrelude { 0: _field_0 } => {
-                <CustomPropertyName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::PropertyPrelude,
+                ));
+                let _field_0 = <CustomPropertyName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::PropertyPrelude { 0: _field_0 }
             }
             AtRulePrelude::CounterStylePrelude { 0: _field_0 } => {
-                <CustomIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::CounterStylePrelude,
+                ));
+                let _field_0 = <CustomIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::CounterStylePrelude { 0: _field_0 }
             }
             AtRulePrelude::ColorProfilePrelude { 0: _field_0 } => {
-                <ColorProfileName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ColorProfilePrelude,
+                ));
+                let _field_0 = <ColorProfileName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::ColorProfilePrelude { 0: _field_0 }
             }
             AtRulePrelude::DocumentPrelude { 0: _field_0 } => {
-                <DocumentPrelude as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::DocumentPrelude,
+                ));
+                let _field_0 = <DocumentPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::DocumentPrelude { 0: _field_0 }
             }
             AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 } => {
-                <DashedIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::FontPaletteValuesPrelude,
+                ));
+                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::FontPaletteValuesPrelude { 0: _field_0 }
             }
             AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 } => {
-                <FontFeatureValuesPrelude as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::FontFeatureValuesPrelude,
+                ));
+                let _field_0 = <FontFeatureValuesPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::FontFeatureValuesPrelude { 0: _field_0 }
             }
             AtRulePrelude::NestPrelude { 0: _field_0 } => {
-                <SelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::NestPrelude,
+                ));
+                let _field_0 = <SelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::NestPrelude { 0: _field_0 }
             }
             AtRulePrelude::KeyframesPrelude { 0: _field_0 } => {
-                <KeyframesName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::KeyframesPrelude,
+                ));
+                let _field_0 = <KeyframesName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::KeyframesPrelude { 0: _field_0 }
             }
             AtRulePrelude::ImportPrelude { 0: _field_0 } => {
-                <ImportPrelude as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ImportPrelude,
+                ));
+                let _field_0 = <ImportPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::ImportPrelude { 0: _field_0 }
             }
             AtRulePrelude::NamespacePrelude { 0: _field_0 } => {
-                <NamespacePrelude as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::NamespacePrelude,
+                ));
+                let _field_0 = <NamespacePrelude as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::NamespacePrelude { 0: _field_0 }
             }
             AtRulePrelude::MediaPrelude { 0: _field_0 } => {
-                <MediaQueryList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::MediaPrelude,
+                ));
+                let _field_0 = <MediaQueryList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::MediaPrelude { 0: _field_0 }
             }
             AtRulePrelude::SupportsPrelude { 0: _field_0 } => {
-                <SupportsCondition as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::SupportsPrelude,
+                ));
+                let _field_0 = <SupportsCondition as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::SupportsPrelude { 0: _field_0 }
             }
             AtRulePrelude::PagePrelude { 0: _field_0 } => {
-                <PageSelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::PagePrelude,
+                ));
+                let _field_0 = <PageSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::PagePrelude { 0: _field_0 }
             }
             AtRulePrelude::LayerPrelude { 0: _field_0 } => {
-                <LayerPrelude as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::LayerPrelude,
+                ));
+                let _field_0 = <LayerPrelude as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::LayerPrelude { 0: _field_0 }
             }
             AtRulePrelude::ContainerPrelude { 0: _field_0 } => {
-                <ContainerCondition as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ContainerPrelude,
+                ));
+                let _field_0 = <ContainerCondition as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::ContainerPrelude { 0: _field_0 }
             }
             AtRulePrelude::CustomMediaPrelude { 0: _field_0 } => {
-                <CustomMediaQuery as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::CustomMediaPrelude,
+                ));
+                let _field_0 = <CustomMediaQuery as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::CustomMediaPrelude { 0: _field_0 }
             }
             AtRulePrelude::ScopePrelude { 0: _field_0 } => {
-                <ScopeRange as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AtRulePrelude(
+                    self::fields::AtRulePreludeField::ScopePrelude,
+                ));
+                let _field_0 = <ScopeRange as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AtRulePrelude::ScopePrelude { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeSelector {
-    #[doc = "Calls [VisitAll`::visit_attribute_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelector {
+    #[doc = "Calls [FoldAstPath`::fold_attribute_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_attribute_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AttributeSelector {
                 span,
@@ -117570,515 +98999,1148 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeSelector {
                 value,
                 modifier,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <WqName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Name,
+                    ));
+                    <WqName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<AttributeSelectorMatcher> as VisitAllWith<V>>::visit_with(
-                        matcher, visitor,
+                let matcher = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Matcher,
+                    ));
+                    <Option<AttributeSelectorMatcher> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        matcher,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Option<AttributeSelectorValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Value,
+                    ));
+                    <Option<AttributeSelectorValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<AttributeSelectorModifier> as VisitAllWith<V>>::visit_with(
-                        modifier, visitor,
+                let modifier = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelector(
+                        self::fields::AttributeSelectorField::Modifier,
+                    ));
+                    <Option<AttributeSelectorModifier> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        modifier,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                AttributeSelector {
+                    span,
+                    name,
+                    matcher,
+                    value,
+                    modifier,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeSelectorMatcher {
-    #[doc = "Calls [VisitAll`::visit_attribute_selector_matcher`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_selector_matcher(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorMatcher {
+    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_matcher`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_attribute_selector_matcher(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AttributeSelectorMatcher { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
+                            self::fields::AttributeSelectorMatcherField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <AttributeSelectorMatcherValue as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorMatcher(
+                            self::fields::AttributeSelectorMatcherField::Value,
+                        ));
+                    <AttributeSelectorMatcherValue as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AttributeSelectorMatcher { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeSelectorMatcherValue {
-    #[doc = "Calls [VisitAll`::visit_attribute_selector_matcher_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_selector_matcher_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorMatcherValue {
+    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_matcher_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_attribute_selector_matcher_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            AttributeSelectorMatcherValue::Equals => {}
-            AttributeSelectorMatcherValue::Tilde => {}
-            AttributeSelectorMatcherValue::Bar => {}
-            AttributeSelectorMatcherValue::Caret => {}
-            AttributeSelectorMatcherValue::Dollar => {}
-            AttributeSelectorMatcherValue::Asterisk => {}
+            AttributeSelectorMatcherValue::Equals => AttributeSelectorMatcherValue::Equals,
+            AttributeSelectorMatcherValue::Tilde => AttributeSelectorMatcherValue::Tilde,
+            AttributeSelectorMatcherValue::Bar => AttributeSelectorMatcherValue::Bar,
+            AttributeSelectorMatcherValue::Caret => AttributeSelectorMatcherValue::Caret,
+            AttributeSelectorMatcherValue::Dollar => AttributeSelectorMatcherValue::Dollar,
+            AttributeSelectorMatcherValue::Asterisk => AttributeSelectorMatcherValue::Asterisk,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeSelectorModifier {
-    #[doc = "Calls [VisitAll`::visit_attribute_selector_modifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_selector_modifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorModifier {
+    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_modifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_attribute_selector_modifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AttributeSelectorModifier { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
+                            self::fields::AttributeSelectorModifierField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::AttributeSelectorModifier(
+                            self::fields::AttributeSelectorModifierField::Value,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AttributeSelectorModifier { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeSelectorValue {
-    #[doc = "Calls [VisitAll`::visit_attribute_selector_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_selector_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AttributeSelectorValue {
+    #[doc = "Calls [FoldAstPath`::fold_attribute_selector_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_attribute_selector_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AttributeSelectorValue::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
+                    self::fields::AttributeSelectorValueField::Str,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AttributeSelectorValue::Str { 0: _field_0 }
             }
             AttributeSelectorValue::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AttributeSelectorValue(
+                    self::fields::AttributeSelectorValueField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AttributeSelectorValue::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BinOp {
-    #[doc = "Calls [VisitAll`::visit_bin_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_bin_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinOp {
+    #[doc = "Calls [FoldAstPath`::fold_bin_op`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_bin_op(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            BinOp::Add => {}
-            BinOp::Sub => {}
-            BinOp::Mul => {}
-            BinOp::Div => {}
+            BinOp::Add => BinOp::Add,
+            BinOp::Sub => BinOp::Sub,
+            BinOp::Mul => BinOp::Mul,
+            BinOp::Div => BinOp::Div,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CalcOperator {
-    #[doc = "Calls [VisitAll`::visit_calc_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcOperator {
+    #[doc = "Calls [FoldAstPath`::fold_calc_operator`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_operator(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CalcOperator { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
+                        self::fields::CalcOperatorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <CalcOperatorType as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcOperator(
+                        self::fields::CalcOperatorField::Value,
+                    ));
+                    <CalcOperatorType as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CalcOperator { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CalcOperatorType {
-    #[doc = "Calls [VisitAll`::visit_calc_operator_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_operator_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcOperatorType {
+    #[doc = "Calls [FoldAstPath`::fold_calc_operator_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_operator_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            CalcOperatorType::Add => {}
-            CalcOperatorType::Sub => {}
-            CalcOperatorType::Mul => {}
-            CalcOperatorType::Div => {}
+            CalcOperatorType::Add => CalcOperatorType::Add,
+            CalcOperatorType::Sub => CalcOperatorType::Sub,
+            CalcOperatorType::Mul => CalcOperatorType::Mul,
+            CalcOperatorType::Div => CalcOperatorType::Div,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CalcProduct {
-    #[doc = "Calls [VisitAll`::visit_calc_product`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_product(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcProduct {
+    #[doc = "Calls [FoldAstPath`::fold_calc_product`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_product(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CalcProduct { span, expressions } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
+                        self::fields::CalcProductField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<CalcValueOrOperator> as VisitAllWith<V>>::visit_with(expressions, visitor)
+                let expressions = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProduct(
+                        self::fields::CalcProductField::Expressions(usize::MAX),
+                    ));
+                    <Vec<CalcValueOrOperator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expressions,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CalcProduct { span, expressions }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CalcProductOrOperator {
-    #[doc = "Calls [VisitAll`::visit_calc_product_or_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_product_or_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcProductOrOperator {
+    #[doc = "Calls [FoldAstPath`::fold_calc_product_or_operator`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_product_or_operator(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CalcProductOrOperator::Product { 0: _field_0 } => {
-                <CalcProduct as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
+                    self::fields::CalcProductOrOperatorField::Product,
+                ));
+                let _field_0 = <CalcProduct as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcProductOrOperator::Product { 0: _field_0 }
             }
             CalcProductOrOperator::Operator { 0: _field_0 } => {
-                <CalcOperator as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcProductOrOperator(
+                    self::fields::CalcProductOrOperatorField::Operator,
+                ));
+                let _field_0 = <CalcOperator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcProductOrOperator::Operator { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CalcSum {
-    #[doc = "Calls [VisitAll`::visit_calc_sum`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_sum(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcSum {
+    #[doc = "Calls [FoldAstPath`::fold_calc_sum`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_sum(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CalcSum { span, expressions } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CalcSum(self::fields::CalcSumField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<CalcProductOrOperator> as VisitAllWith<V>>::visit_with(
+                let expressions = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcSum(
+                        self::fields::CalcSumField::Expressions(usize::MAX),
+                    ));
+                    <Vec<CalcProductOrOperator> as FoldWithAstPath<V>>::fold_with_ast_path(
                         expressions,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                CalcSum { span, expressions }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CalcValue {
-    #[doc = "Calls [VisitAll`::visit_calc_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcValue {
+    #[doc = "Calls [FoldAstPath`::fold_calc_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CalcValue::Number { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Number,
+                ));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValue::Number { 0: _field_0 }
             }
             CalcValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Dimension,
+                ));
+                let _field_0 = <Dimension as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValue::Dimension { 0: _field_0 }
             }
             CalcValue::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValue::Percentage { 0: _field_0 }
             }
             CalcValue::Constant { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Constant,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValue::Constant { 0: _field_0 }
             }
             CalcValue::Sum { 0: _field_0 } => {
-                <CalcSum as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::CalcValue(self::fields::CalcValueField::Sum));
+                let _field_0 = <CalcSum as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValue::Sum { 0: _field_0 }
             }
             CalcValue::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValue(
+                    self::fields::CalcValueField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValue::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CalcValueOrOperator {
-    #[doc = "Calls [VisitAll`::visit_calc_value_or_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_value_or_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CalcValueOrOperator {
+    #[doc = "Calls [FoldAstPath`::fold_calc_value_or_operator`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_value_or_operator(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CalcValueOrOperator::Value { 0: _field_0 } => {
-                <CalcValue as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
+                    self::fields::CalcValueOrOperatorField::Value,
+                ));
+                let _field_0 = <CalcValue as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValueOrOperator::Value { 0: _field_0 }
             }
             CalcValueOrOperator::Operator { 0: _field_0 } => {
-                <CalcOperator as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CalcValueOrOperator(
+                    self::fields::CalcValueOrOperatorField::Operator,
+                ));
+                let _field_0 = <CalcOperator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CalcValueOrOperator::Operator { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassSelector {
-    #[doc = "Calls [VisitAll`::visit_class_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassSelector {
+    #[doc = "Calls [FoldAstPath`::fold_class_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ClassSelector { span, text } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
+                        self::fields::ClassSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(text, visitor)
+                let text = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassSelector(
+                        self::fields::ClassSelectorField::Text,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        text,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ClassSelector { span, text }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CmykComponent {
-    #[doc = "Calls [VisitAll`::visit_cmyk_component`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_cmyk_component(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CmykComponent {
+    #[doc = "Calls [FoldAstPath`::fold_cmyk_component`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_cmyk_component(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CmykComponent::Number { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
+                    self::fields::CmykComponentField::Number,
+                ));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CmykComponent::Number { 0: _field_0 }
             }
             CmykComponent::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
+                    self::fields::CmykComponentField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CmykComponent::Percentage { 0: _field_0 }
             }
             CmykComponent::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::CmykComponent(
+                    self::fields::CmykComponentField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CmykComponent::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Color {
-    #[doc = "Calls [VisitAll`::visit_color`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_color(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Color {
+    #[doc = "Calls [FoldAstPath`::fold_color`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_color(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Color::AbsoluteColorBase { 0: _field_0 } => {
-                <AbsoluteColorBase as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
+                    self::fields::ColorField::AbsoluteColorBase,
+                ));
+                let _field_0 = <AbsoluteColorBase as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Color::AbsoluteColorBase { 0: _field_0 }
             }
             Color::CurrentColorOrSystemColor { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Color(
+                    self::fields::ColorField::CurrentColorOrSystemColor,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Color::CurrentColorOrSystemColor { 0: _field_0 }
             }
             Color::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Color(self::fields::ColorField::Function));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Color::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ColorProfileName {
-    #[doc = "Calls [VisitAll`::visit_color_profile_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_color_profile_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ColorProfileName {
+    #[doc = "Calls [FoldAstPath`::fold_color_profile_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_color_profile_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ColorProfileName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
+                    self::fields::ColorProfileNameField::DashedIdent,
+                ));
+                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ColorProfileName::DashedIdent { 0: _field_0 }
             }
             ColorProfileName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ColorProfileName(
+                    self::fields::ColorProfileNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ColorProfileName::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Combinator {
-    #[doc = "Calls [VisitAll`::visit_combinator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_combinator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Combinator {
+    #[doc = "Calls [FoldAstPath`::fold_combinator`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_combinator(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Combinator { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
+                        self::fields::CombinatorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <CombinatorValue as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Combinator(
+                        self::fields::CombinatorField::Value,
+                    ));
+                    <CombinatorValue as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Combinator { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CombinatorValue {
-    #[doc = "Calls [VisitAll`::visit_combinator_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_combinator_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CombinatorValue {
+    #[doc = "Calls [FoldAstPath`::fold_combinator_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_combinator_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            CombinatorValue::Descendant => {}
-            CombinatorValue::NextSibling => {}
-            CombinatorValue::Child => {}
-            CombinatorValue::LaterSibling => {}
-            CombinatorValue::Column => {}
+            CombinatorValue::Descendant => CombinatorValue::Descendant,
+            CombinatorValue::NextSibling => CombinatorValue::NextSibling,
+            CombinatorValue::Child => CombinatorValue::Child,
+            CombinatorValue::LaterSibling => CombinatorValue::LaterSibling,
+            CombinatorValue::Column => CombinatorValue::Column,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ComplexSelector {
-    #[doc = "Calls [VisitAll`::visit_complex_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_complex_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComplexSelector {
+    #[doc = "Calls [FoldAstPath`::fold_complex_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_complex_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ComplexSelector { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
+                        self::fields::ComplexSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ComplexSelectorChildren> as VisitAllWith<V>>::visit_with(children, visitor)
+                let children = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelector(
+                        self::fields::ComplexSelectorField::Children(usize::MAX),
+                    ));
+                    <Vec<ComplexSelectorChildren> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ComplexSelector { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ComplexSelectorChildren {
-    #[doc = "Calls [VisitAll`::visit_complex_selector_children`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_complex_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComplexSelectorChildren {
+    #[doc = "Calls [FoldAstPath`::fold_complex_selector_children`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_complex_selector_children(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ComplexSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
+                    self::fields::ComplexSelectorChildrenField::CompoundSelector,
+                ));
+                let _field_0 = <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComplexSelectorChildren::CompoundSelector { 0: _field_0 }
             }
             ComplexSelectorChildren::Combinator { 0: _field_0 } => {
-                <Combinator as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComplexSelectorChildren(
+                    self::fields::ComplexSelectorChildrenField::Combinator,
+                ));
+                let _field_0 = <Combinator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComplexSelectorChildren::Combinator { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ComponentValue {
-    #[doc = "Calls [VisitAll`::visit_component_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_component_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComponentValue {
+    #[doc = "Calls [FoldAstPath`::fold_component_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_component_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ComponentValue::PreservedToken { 0: _field_0 } => {
-                <Box<TokenAndSpan> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::PreservedToken,
+                ));
+                let _field_0 = <Box<TokenAndSpan> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::PreservedToken { 0: _field_0 }
             }
             ComponentValue::Function { 0: _field_0 } => {
-                <Box<Function> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Function,
+                ));
+                let _field_0 = <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Function { 0: _field_0 }
             }
             ComponentValue::SimpleBlock { 0: _field_0 } => {
-                <Box<SimpleBlock> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::SimpleBlock,
+                ));
+                let _field_0 = <Box<SimpleBlock> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::SimpleBlock { 0: _field_0 }
             }
             ComponentValue::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::AtRule,
+                ));
+                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::AtRule { 0: _field_0 }
             }
             ComponentValue::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::QualifiedRule,
+                ));
+                let _field_0 = <Box<QualifiedRule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::QualifiedRule { 0: _field_0 }
             }
             ComponentValue::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::ListOfComponentValues,
+                ));
+                let _field_0 =
+                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                ComponentValue::ListOfComponentValues { 0: _field_0 }
             }
             ComponentValue::KeyframeBlock { 0: _field_0 } => {
-                <Box<KeyframeBlock> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::KeyframeBlock,
+                ));
+                let _field_0 = <Box<KeyframeBlock> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::KeyframeBlock { 0: _field_0 }
             }
             ComponentValue::Ident { 0: _field_0 } => {
-                <Box<Ident> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Ident,
+                ));
+                let _field_0 = <Box<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Ident { 0: _field_0 }
             }
             ComponentValue::DashedIdent { 0: _field_0 } => {
-                <Box<DashedIdent> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::DashedIdent,
+                ));
+                let _field_0 = <Box<DashedIdent> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::DashedIdent { 0: _field_0 }
             }
             ComponentValue::Str { 0: _field_0 } => {
-                <Box<Str> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Str,
+                ));
+                let _field_0 = <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Str { 0: _field_0 }
             }
             ComponentValue::Url { 0: _field_0 } => {
-                <Box<Url> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Url,
+                ));
+                let _field_0 = <Box<Url> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Url { 0: _field_0 }
             }
             ComponentValue::Integer { 0: _field_0 } => {
-                <Box<Integer> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Integer,
+                ));
+                let _field_0 = <Box<Integer> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Integer { 0: _field_0 }
             }
             ComponentValue::Number { 0: _field_0 } => {
-                <Box<Number> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Number,
+                ));
+                let _field_0 = <Box<Number> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Number { 0: _field_0 }
             }
             ComponentValue::Percentage { 0: _field_0 } => {
-                <Box<Percentage> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Percentage,
+                ));
+                let _field_0 = <Box<Percentage> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Percentage { 0: _field_0 }
             }
             ComponentValue::Dimension { 0: _field_0 } => {
-                <Box<Dimension> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Dimension,
+                ));
+                let _field_0 = <Box<Dimension> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Dimension { 0: _field_0 }
             }
             ComponentValue::LengthPercentage { 0: _field_0 } => {
-                <Box<LengthPercentage> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::LengthPercentage,
+                ));
+                let _field_0 = <Box<LengthPercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::LengthPercentage { 0: _field_0 }
             }
             ComponentValue::FrequencyPercentage { 0: _field_0 } => {
-                <Box<FrequencyPercentage> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::FrequencyPercentage,
+                ));
+                let _field_0 = <Box<FrequencyPercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::FrequencyPercentage { 0: _field_0 }
             }
             ComponentValue::AnglePercentage { 0: _field_0 } => {
-                <Box<AnglePercentage> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::AnglePercentage,
+                ));
+                let _field_0 = <Box<AnglePercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::AnglePercentage { 0: _field_0 }
             }
             ComponentValue::TimePercentage { 0: _field_0 } => {
-                <Box<TimePercentage> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::TimePercentage,
+                ));
+                let _field_0 = <Box<TimePercentage> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::TimePercentage { 0: _field_0 }
             }
             ComponentValue::Ratio { 0: _field_0 } => {
-                <Box<Ratio> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Ratio,
+                ));
+                let _field_0 = <Box<Ratio> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Ratio { 0: _field_0 }
             }
             ComponentValue::UnicodeRange { 0: _field_0 } => {
-                <Box<UnicodeRange> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::UnicodeRange,
+                ));
+                let _field_0 = <Box<UnicodeRange> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::UnicodeRange { 0: _field_0 }
             }
             ComponentValue::Color { 0: _field_0 } => {
-                <Box<Color> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Color,
+                ));
+                let _field_0 = <Box<Color> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Color { 0: _field_0 }
             }
             ComponentValue::AlphaValue { 0: _field_0 } => {
-                <Box<AlphaValue> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::AlphaValue,
+                ));
+                let _field_0 = <Box<AlphaValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::AlphaValue { 0: _field_0 }
             }
             ComponentValue::Hue { 0: _field_0 } => {
-                <Box<Hue> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Hue,
+                ));
+                let _field_0 = <Box<Hue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Hue { 0: _field_0 }
             }
             ComponentValue::CmykComponent { 0: _field_0 } => {
-                <Box<CmykComponent> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::CmykComponent,
+                ));
+                let _field_0 = <Box<CmykComponent> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::CmykComponent { 0: _field_0 }
             }
             ComponentValue::Delimiter { 0: _field_0 } => {
-                <Box<Delimiter> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Delimiter,
+                ));
+                let _field_0 = <Box<Delimiter> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Delimiter { 0: _field_0 }
             }
             ComponentValue::CalcSum { 0: _field_0 } => {
-                <Box<CalcSum> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::CalcSum,
+                ));
+                let _field_0 = <Box<CalcSum> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::CalcSum { 0: _field_0 }
             }
             ComponentValue::ComplexSelector { 0: _field_0 } => {
-                <Box<ComplexSelector> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::ComplexSelector,
+                ));
+                let _field_0 = <Box<ComplexSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::ComplexSelector { 0: _field_0 }
             }
             ComponentValue::LayerName { 0: _field_0 } => {
-                <Box<LayerName> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::LayerName,
+                ));
+                let _field_0 = <Box<LayerName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::LayerName { 0: _field_0 }
             }
             ComponentValue::SupportsCondition { 0: _field_0 } => {
-                <Box<SupportsCondition> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::SupportsCondition,
+                ));
+                let _field_0 = <Box<SupportsCondition> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::SupportsCondition { 0: _field_0 }
             }
             ComponentValue::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::Declaration,
+                ));
+                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::Declaration { 0: _field_0 }
             }
             ComponentValue::IdSelector { 0: _field_0 } => {
-                <Box<IdSelector> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ComponentValue(
+                    self::fields::ComponentValueField::IdSelector,
+                ));
+                let _field_0 = <Box<IdSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ComponentValue::IdSelector { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CompoundSelector {
-    #[doc = "Calls [VisitAll`::visit_compound_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_compound_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CompoundSelector {
+    #[doc = "Calls [FoldAstPath`::fold_compound_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_compound_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CompoundSelector {
                 span,
@@ -118086,340 +100148,695 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for CompoundSelector {
                 type_selector,
                 subclass_selectors,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<NestingSelector> as VisitAllWith<V>>::visit_with(
+                let nesting_selector = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::NestingSelector,
+                    ));
+                    <Option<NestingSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
                         nesting_selector,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Option<Box<TypeSelector>> as VisitAllWith<V>>::visit_with(
+                let type_selector = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::TypeSelector,
+                    ));
+                    <Option<Box<TypeSelector>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_selector,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Vec<SubclassSelector> as VisitAllWith<V>>::visit_with(
+                let subclass_selectors = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CompoundSelector(
+                        self::fields::CompoundSelectorField::SubclassSelectors(usize::MAX),
+                    ));
+                    <Vec<SubclassSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
                         subclass_selectors,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                CompoundSelector {
+                    span,
+                    nesting_selector,
+                    type_selector,
+                    subclass_selectors,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CompoundSelectorList {
-    #[doc = "Calls [VisitAll`::visit_compound_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_compound_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CompoundSelectorList {
+    #[doc = "Calls [FoldAstPath`::fold_compound_selector_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_compound_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CompoundSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
+                            self::fields::CompoundSelectorListField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<CompoundSelector> as VisitAllWith<V>>::visit_with(children, visitor)
+                let children = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::CompoundSelectorList(
+                            self::fields::CompoundSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<CompoundSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CompoundSelectorList { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContainerCondition {
-    #[doc = "Calls [VisitAll`::visit_container_condition`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerCondition {
+    #[doc = "Calls [FoldAstPath`::fold_container_condition`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_condition(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContainerCondition { span, name, query } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
+                        self::fields::ContainerConditionField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<ContainerName> as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
+                        self::fields::ContainerConditionField::Name,
+                    ));
+                    <Option<ContainerName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ContainerQuery as VisitAllWith<V>>::visit_with(query, visitor)
+                let query = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerCondition(
+                        self::fields::ContainerConditionField::Query,
+                    ));
+                    <ContainerQuery as FoldWithAstPath<V>>::fold_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ContainerCondition { span, name, query }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContainerName {
-    #[doc = "Calls [VisitAll`::visit_container_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerName {
+    #[doc = "Calls [FoldAstPath`::fold_container_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContainerName::CustomIdent { 0: _field_0 } => {
-                <CustomIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerName(
+                    self::fields::ContainerNameField::CustomIdent,
+                ));
+                let _field_0 = <CustomIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ContainerName::CustomIdent { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContainerQuery {
-    #[doc = "Calls [VisitAll`::visit_container_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQuery {
+    #[doc = "Calls [FoldAstPath`::fold_container_query`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_query(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContainerQuery { span, queries } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
+                        self::fields::ContainerQueryField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ContainerQueryType> as VisitAllWith<V>>::visit_with(queries, visitor)
+                let queries = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQuery(
+                        self::fields::ContainerQueryField::Queries(usize::MAX),
+                    ));
+                    <Vec<ContainerQueryType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        queries,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ContainerQuery { span, queries }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContainerQueryAnd {
-    #[doc = "Calls [VisitAll`::visit_container_query_and`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_query_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryAnd {
+    #[doc = "Calls [FoldAstPath`::fold_container_query_and`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_query_and(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContainerQueryAnd {
                 span,
                 keyword,
                 query,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
+                        self::fields::ContainerQueryAndField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
+                        self::fields::ContainerQueryAndField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <QueryInParens as VisitAllWith<V>>::visit_with(query, visitor)
+                let query = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryAnd(
+                        self::fields::ContainerQueryAndField::Query,
+                    ));
+                    <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ContainerQueryAnd {
+                    span,
+                    keyword,
+                    query,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContainerQueryNot {
-    #[doc = "Calls [VisitAll`::visit_container_query_not`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_query_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryNot {
+    #[doc = "Calls [FoldAstPath`::fold_container_query_not`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_query_not(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContainerQueryNot {
                 span,
                 keyword,
                 query,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
+                        self::fields::ContainerQueryNotField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
+                        self::fields::ContainerQueryNotField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <QueryInParens as VisitAllWith<V>>::visit_with(query, visitor)
+                let query = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryNot(
+                        self::fields::ContainerQueryNotField::Query,
+                    ));
+                    <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ContainerQueryNot {
+                    span,
+                    keyword,
+                    query,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContainerQueryOr {
-    #[doc = "Calls [VisitAll`::visit_container_query_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_query_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryOr {
+    #[doc = "Calls [FoldAstPath`::fold_container_query_or`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_query_or(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContainerQueryOr {
                 span,
                 keyword,
                 query,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
+                        self::fields::ContainerQueryOrField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
+                        self::fields::ContainerQueryOrField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <QueryInParens as VisitAllWith<V>>::visit_with(query, visitor)
+                let query = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryOr(
+                        self::fields::ContainerQueryOrField::Query,
+                    ));
+                    <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                        query,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ContainerQueryOr {
+                    span,
+                    keyword,
+                    query,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContainerQueryType {
-    #[doc = "Calls [VisitAll`::visit_container_query_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_query_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContainerQueryType {
+    #[doc = "Calls [FoldAstPath`::fold_container_query_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_query_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContainerQueryType::Not { 0: _field_0 } => {
-                <ContainerQueryNot as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::Not,
+                ));
+                let _field_0 = <ContainerQueryNot as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ContainerQueryType::Not { 0: _field_0 }
             }
             ContainerQueryType::And { 0: _field_0 } => {
-                <ContainerQueryAnd as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::And,
+                ));
+                let _field_0 = <ContainerQueryAnd as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ContainerQueryType::And { 0: _field_0 }
             }
             ContainerQueryType::Or { 0: _field_0 } => {
-                <ContainerQueryOr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::Or,
+                ));
+                let _field_0 = <ContainerQueryOr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ContainerQueryType::Or { 0: _field_0 }
             }
             ContainerQueryType::QueryInParens { 0: _field_0 } => {
-                <QueryInParens as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ContainerQueryType(
+                    self::fields::ContainerQueryTypeField::QueryInParens,
+                ));
+                let _field_0 = <QueryInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ContainerQueryType::QueryInParens { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CustomHighlightName {
-    #[doc = "Calls [VisitAll`::visit_custom_highlight_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_custom_highlight_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomHighlightName {
+    #[doc = "Calls [FoldAstPath`::fold_custom_highlight_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_custom_highlight_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CustomHighlightName { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
+                        self::fields::CustomHighlightNameField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
+                        self::fields::CustomHighlightNameField::Value,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomHighlightName(
+                        self::fields::CustomHighlightNameField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CustomHighlightName { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CustomIdent {
-    #[doc = "Calls [VisitAll`::visit_custom_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_custom_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomIdent {
+    #[doc = "Calls [FoldAstPath`::fold_custom_ident`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_custom_ident(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CustomIdent { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
+                        self::fields::CustomIdentField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
+                        self::fields::CustomIdentField::Value,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomIdent(
+                        self::fields::CustomIdentField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CustomIdent { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CustomMediaQuery {
-    #[doc = "Calls [VisitAll`::visit_custom_media_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_custom_media_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomMediaQuery {
+    #[doc = "Calls [FoldAstPath`::fold_custom_media_query`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_custom_media_query(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CustomMediaQuery { span, name, media } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
+                        self::fields::CustomMediaQueryField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ExtensionName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
+                        self::fields::CustomMediaQueryField::Name,
+                    ));
+                    <ExtensionName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <CustomMediaQueryMediaType as VisitAllWith<V>>::visit_with(media, visitor)
+                let media = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomMediaQuery(
+                        self::fields::CustomMediaQueryField::Media,
+                    ));
+                    <CustomMediaQueryMediaType as FoldWithAstPath<V>>::fold_with_ast_path(
+                        media,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CustomMediaQuery { span, name, media }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CustomMediaQueryMediaType {
-    #[doc = "Calls [VisitAll`::visit_custom_media_query_media_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_custom_media_query_media_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomMediaQueryMediaType {
+    #[doc = "Calls [FoldAstPath`::fold_custom_media_query_media_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_custom_media_query_media_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CustomMediaQueryMediaType::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
+                        self::fields::CustomMediaQueryMediaTypeField::Ident,
+                    ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CustomMediaQueryMediaType::Ident { 0: _field_0 }
             }
             CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 } => {
-                <MediaQueryList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::CustomMediaQueryMediaType(
+                        self::fields::CustomMediaQueryMediaTypeField::MediaQueryList,
+                    ));
+                let _field_0 = <MediaQueryList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                CustomMediaQueryMediaType::MediaQueryList { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CustomPropertyName {
-    #[doc = "Calls [VisitAll`::visit_custom_property_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_custom_property_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CustomPropertyName {
+    #[doc = "Calls [FoldAstPath`::fold_custom_property_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_custom_property_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CustomPropertyName { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
+                        self::fields::CustomPropertyNameField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
+                        self::fields::CustomPropertyNameField::Value,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CustomPropertyName(
+                        self::fields::CustomPropertyNameField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CustomPropertyName { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DashedIdent {
-    #[doc = "Calls [VisitAll`::visit_dashed_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_dashed_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DashedIdent {
+    #[doc = "Calls [FoldAstPath`::fold_dashed_ident`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_dashed_ident(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DashedIdent { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
+                        self::fields::DashedIdentField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
+                        self::fields::DashedIdentField::Value,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DashedIdent(
+                        self::fields::DashedIdentField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                DashedIdent { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Declaration {
-    #[doc = "Calls [VisitAll`::visit_declaration`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_declaration(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Declaration {
+    #[doc = "Calls [FoldAstPath`::fold_declaration`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_declaration(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Declaration {
                 span,
@@ -118427,131 +100844,286 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Declaration {
                 value,
                 important,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <DeclarationName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Name,
+                    ));
+                    <DeclarationName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ComponentValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<ImportantFlag> as VisitAllWith<V>>::visit_with(important, visitor)
+                let important = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Declaration(
+                        self::fields::DeclarationField::Important,
+                    ));
+                    <Option<ImportantFlag> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        important,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Declaration {
+                    span,
+                    name,
+                    value,
+                    important,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DeclarationName {
-    #[doc = "Calls [VisitAll`::visit_declaration_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_declaration_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DeclarationName {
+    #[doc = "Calls [FoldAstPath`::fold_declaration_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_declaration_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DeclarationName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
+                    self::fields::DeclarationNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DeclarationName::Ident { 0: _field_0 }
             }
             DeclarationName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationName(
+                    self::fields::DeclarationNameField::DashedIdent,
+                ));
+                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DeclarationName::DashedIdent { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DeclarationOrAtRule {
-    #[doc = "Calls [VisitAll`::visit_declaration_or_at_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_declaration_or_at_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DeclarationOrAtRule {
+    #[doc = "Calls [FoldAstPath`::fold_declaration_or_at_rule`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_declaration_or_at_rule(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DeclarationOrAtRule::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
+                    self::fields::DeclarationOrAtRuleField::Declaration,
+                ));
+                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DeclarationOrAtRule::Declaration { 0: _field_0 }
             }
             DeclarationOrAtRule::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
+                    self::fields::DeclarationOrAtRuleField::AtRule,
+                ));
+                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DeclarationOrAtRule::AtRule { 0: _field_0 }
             }
             DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DeclarationOrAtRule(
+                    self::fields::DeclarationOrAtRuleField::ListOfComponentValues,
+                ));
+                let _field_0 =
+                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                DeclarationOrAtRule::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Delimiter {
-    #[doc = "Calls [VisitAll`::visit_delimiter`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_delimiter(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Delimiter {
+    #[doc = "Calls [FoldAstPath`::fold_delimiter`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_delimiter(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Delimiter { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Delimiter(self::fields::DelimiterField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <DelimiterValue as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Delimiter(
+                        self::fields::DelimiterField::Value,
+                    ));
+                    <DelimiterValue as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Delimiter { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DelimiterValue {
-    #[doc = "Calls [VisitAll`::visit_delimiter_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_delimiter_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DelimiterValue {
+    #[doc = "Calls [FoldAstPath`::fold_delimiter_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_delimiter_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            DelimiterValue::Comma => {}
-            DelimiterValue::Solidus => {}
-            DelimiterValue::Semicolon => {}
+            DelimiterValue::Comma => DelimiterValue::Comma,
+            DelimiterValue::Solidus => DelimiterValue::Solidus,
+            DelimiterValue::Semicolon => DelimiterValue::Semicolon,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Dimension {
-    #[doc = "Calls [VisitAll`::visit_dimension`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_dimension(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Dimension {
+    #[doc = "Calls [FoldAstPath`::fold_dimension`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_dimension(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Dimension::Length { 0: _field_0 } => {
-                <Length as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Length,
+                ));
+                let _field_0 = <Length as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Dimension::Length { 0: _field_0 }
             }
             Dimension::Angle { 0: _field_0 } => {
-                <Angle as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Angle,
+                ));
+                let _field_0 = <Angle as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Dimension::Angle { 0: _field_0 }
             }
             Dimension::Time { 0: _field_0 } => {
-                <Time as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Time));
+                let _field_0 = <Time as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Dimension::Time { 0: _field_0 }
             }
             Dimension::Frequency { 0: _field_0 } => {
-                <Frequency as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Frequency,
+                ));
+                let _field_0 = <Frequency as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Dimension::Frequency { 0: _field_0 }
             }
             Dimension::Resolution { 0: _field_0 } => {
-                <Resolution as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::Resolution,
+                ));
+                let _field_0 = <Resolution as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Dimension::Resolution { 0: _field_0 }
             }
             Dimension::Flex { 0: _field_0 } => {
-                <Flex as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Dimension(self::fields::DimensionField::Flex));
+                let _field_0 = <Flex as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Dimension::Flex { 0: _field_0 }
             }
             Dimension::UnknownDimension { 0: _field_0 } => {
-                <UnknownDimension as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Dimension(
+                    self::fields::DimensionField::UnknownDimension,
+                ));
+                let _field_0 = <UnknownDimension as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Dimension::UnknownDimension { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DimensionToken {
-    #[doc = "Calls [VisitAll`::visit_dimension_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_dimension_token(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DimensionToken {
+    #[doc = "Calls [FoldAstPath`::fold_dimension_token`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_dimension_token(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DimensionToken {
                 value,
@@ -118560,462 +101132,929 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for DimensionToken {
                 type_flag,
                 raw_unit,
             } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw_value, visitor)
+                let raw_value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::RawValue,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw_value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::Unit,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <NumberType as VisitAllWith<V>>::visit_with(type_flag, visitor)
+                let type_flag = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::TypeFlag,
+                    ));
+                    <NumberType as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_flag,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw_unit, visitor)
+                let raw_unit = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DimensionToken(
+                        self::fields::DimensionTokenField::RawUnit,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw_unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                DimensionToken {
+                    value,
+                    raw_value,
+                    unit,
+                    type_flag,
+                    raw_unit,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DocumentPrelude {
-    #[doc = "Calls [VisitAll`::visit_document_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DocumentPrelude {
+    #[doc = "Calls [FoldAstPath`::fold_document_prelude`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_document_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DocumentPrelude {
                 span,
                 matching_functions,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
+                        self::fields::DocumentPreludeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<DocumentPreludeMatchingFunction> as VisitAllWith<V>>::visit_with(
+                let matching_functions = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DocumentPrelude(
+                        self::fields::DocumentPreludeField::MatchingFunctions(usize::MAX),
+                    ));
+                    <Vec<DocumentPreludeMatchingFunction> as FoldWithAstPath<V>>::fold_with_ast_path(
                         matching_functions,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                DocumentPrelude {
+                    span,
+                    matching_functions,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DocumentPreludeMatchingFunction {
-    #[doc = "Calls [VisitAll`::visit_document_prelude_matching_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_prelude_matching_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DocumentPreludeMatchingFunction {
+    #[doc = "Calls [FoldAstPath`::fold_document_prelude_matching_function`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_document_prelude_matching_function(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DocumentPreludeMatchingFunction::Url { 0: _field_0 } => {
-                <Url as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
+                        self::fields::DocumentPreludeMatchingFunctionField::Url,
+                    ));
+                let _field_0 = <Url as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DocumentPreludeMatchingFunction::Url { 0: _field_0 }
             }
             DocumentPreludeMatchingFunction::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::DocumentPreludeMatchingFunction(
+                        self::fields::DocumentPreludeMatchingFunctionField::Function,
+                    ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DocumentPreludeMatchingFunction::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExtensionName {
-    #[doc = "Calls [VisitAll`::visit_extension_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_extension_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExtensionName {
+    #[doc = "Calls [FoldAstPath`::fold_extension_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_extension_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExtensionName { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
+                        self::fields::ExtensionNameField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
+                        self::fields::ExtensionNameField::Value,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExtensionName(
+                        self::fields::ExtensionNameField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExtensionName { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for FamilyName {
-    #[doc = "Calls [VisitAll`::visit_family_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_family_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FamilyName {
+    #[doc = "Calls [FoldAstPath`::fold_family_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_family_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             FamilyName::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
+                    self::fields::FamilyNameField::Str,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                FamilyName::Str { 0: _field_0 }
             }
             FamilyName::SequenceOfCustomIdents { 0: _field_0 } => {
-                <SequenceOfCustomIdents as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FamilyName(
+                    self::fields::FamilyNameField::SequenceOfCustomIdents,
+                ));
+                let _field_0 = <SequenceOfCustomIdents as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                FamilyName::SequenceOfCustomIdents { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Flex {
-    #[doc = "Calls [VisitAll`::visit_flex`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_flex(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Flex {
+    #[doc = "Calls [FoldAstPath`::fold_flex`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_flex(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Flex { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Value));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Flex(self::fields::FlexField::Unit));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Flex { span, value, unit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for FontFeatureValuesPrelude {
-    #[doc = "Calls [VisitAll`::visit_font_feature_values_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_font_feature_values_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FontFeatureValuesPrelude {
+    #[doc = "Calls [FoldAstPath`::fold_font_feature_values_prelude`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_font_feature_values_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             FontFeatureValuesPrelude { span, font_family } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
+                            self::fields::FontFeatureValuesPreludeField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<FamilyName> as VisitAllWith<V>>::visit_with(font_family, visitor)
+                let font_family = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::FontFeatureValuesPrelude(
+                            self::fields::FontFeatureValuesPreludeField::FontFamily(usize::MAX),
+                        ));
+                    <Vec<FamilyName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        font_family,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                FontFeatureValuesPrelude { span, font_family }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForgivingComplexSelector {
-    #[doc = "Calls [VisitAll`::visit_forgiving_complex_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_forgiving_complex_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingComplexSelector {
+    #[doc = "Calls [FoldAstPath`::fold_forgiving_complex_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_forgiving_complex_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForgivingComplexSelector::ComplexSelector { 0: _field_0 } => {
-                <ComplexSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
+                        self::fields::ForgivingComplexSelectorField::ComplexSelector,
+                    ));
+                let _field_0 = <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ForgivingComplexSelector::ComplexSelector { 0: _field_0 }
             }
             ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingComplexSelector(
+                        self::fields::ForgivingComplexSelectorField::ListOfComponentValues,
+                    ));
+                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ForgivingComplexSelector::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForgivingRelativeSelector {
-    #[doc = "Calls [VisitAll`::visit_forgiving_relative_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_forgiving_relative_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingRelativeSelector {
+    #[doc = "Calls [FoldAstPath`::fold_forgiving_relative_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_forgiving_relative_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForgivingRelativeSelector::RelativeSelector { 0: _field_0 } => {
-                <RelativeSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
+                        self::fields::ForgivingRelativeSelectorField::RelativeSelector,
+                    ));
+                let _field_0 = <RelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ForgivingRelativeSelector::RelativeSelector { 0: _field_0 }
             }
             ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForgivingRelativeSelector(
+                        self::fields::ForgivingRelativeSelectorField::ListOfComponentValues,
+                    ));
+                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ForgivingRelativeSelector::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForgivingRelativeSelectorList {
-    #[doc = "Calls [VisitAll`::visit_forgiving_relative_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_forgiving_relative_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingRelativeSelectorList {
+    #[doc = "Calls [FoldAstPath`::fold_forgiving_relative_selector_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_forgiving_relative_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForgivingRelativeSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
+                            self::fields::ForgivingRelativeSelectorListField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ForgivingRelativeSelector> as VisitAllWith<V>>::visit_with(
-                        children, visitor,
+                let children = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingRelativeSelectorList(
+                            self::fields::ForgivingRelativeSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<ForgivingRelativeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                ForgivingRelativeSelectorList { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForgivingSelectorList {
-    #[doc = "Calls [VisitAll`::visit_forgiving_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_forgiving_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForgivingSelectorList {
+    #[doc = "Calls [FoldAstPath`::fold_forgiving_selector_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_forgiving_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForgivingSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
+                            self::fields::ForgivingSelectorListField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ForgivingComplexSelector> as VisitAllWith<V>>::visit_with(
-                        children, visitor,
+                let children = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ForgivingSelectorList(
+                            self::fields::ForgivingSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<ForgivingComplexSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                ForgivingSelectorList { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Frequency {
-    #[doc = "Calls [VisitAll`::visit_frequency`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_frequency(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Frequency {
+    #[doc = "Calls [FoldAstPath`::fold_frequency`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_frequency(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Frequency { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Frequency(
+                        self::fields::FrequencyField::Value,
+                    ));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Frequency(self::fields::FrequencyField::Unit));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Frequency { span, value, unit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for FrequencyPercentage {
-    #[doc = "Calls [VisitAll`::visit_frequency_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_frequency_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FrequencyPercentage {
+    #[doc = "Calls [FoldAstPath`::fold_frequency_percentage`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_frequency_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             FrequencyPercentage::Frequency { 0: _field_0 } => {
-                <Frequency as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
+                    self::fields::FrequencyPercentageField::Frequency,
+                ));
+                let _field_0 = <Frequency as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                FrequencyPercentage::Frequency { 0: _field_0 }
             }
             FrequencyPercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FrequencyPercentage(
+                    self::fields::FrequencyPercentageField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                FrequencyPercentage::Percentage { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Function {
-    #[doc = "Calls [VisitAll`::visit_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Function {
+    #[doc = "Calls [FoldAstPath`::fold_function`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_function(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Function { span, name, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <FunctionName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Name));
+                    <FunctionName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ComponentValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Function { span, name, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for FunctionName {
-    #[doc = "Calls [VisitAll`::visit_function_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_function_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FunctionName {
+    #[doc = "Calls [FoldAstPath`::fold_function_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_function_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             FunctionName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
+                    self::fields::FunctionNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                FunctionName::Ident { 0: _field_0 }
             }
             FunctionName::DashedIdent { 0: _field_0 } => {
-                <DashedIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::FunctionName(
+                    self::fields::FunctionNameField::DashedIdent,
+                ));
+                let _field_0 = <DashedIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                FunctionName::DashedIdent { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for GeneralEnclosed {
-    #[doc = "Calls [VisitAll`::visit_general_enclosed`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_general_enclosed(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for GeneralEnclosed {
+    #[doc = "Calls [FoldAstPath`::fold_general_enclosed`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_general_enclosed(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             GeneralEnclosed::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
+                    self::fields::GeneralEnclosedField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                GeneralEnclosed::Function { 0: _field_0 }
             }
             GeneralEnclosed::SimpleBlock { 0: _field_0 } => {
-                <SimpleBlock as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::GeneralEnclosed(
+                    self::fields::GeneralEnclosedField::SimpleBlock,
+                ));
+                let _field_0 = <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                GeneralEnclosed::SimpleBlock { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for HexColor {
-    #[doc = "Calls [VisitAll`::visit_hex_color`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_hex_color(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for HexColor {
+    #[doc = "Calls [FoldAstPath`::fold_hex_color`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_hex_color(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             HexColor { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::HexColor(self::fields::HexColorField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                HexColor { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Hue {
-    #[doc = "Calls [VisitAll`::visit_hue`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_hue(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Hue {
+    #[doc = "Calls [FoldAstPath`::fold_hue`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_hue(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Hue::Number { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Number));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Hue::Number { 0: _field_0 }
             }
             Hue::Angle { 0: _field_0 } => {
-                <Angle as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Hue(self::fields::HueField::Angle));
+                let _field_0 = <Angle as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Hue::Angle { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for IdSelector {
-    #[doc = "Calls [VisitAll`::visit_id_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_id_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for IdSelector {
+    #[doc = "Calls [FoldAstPath`::fold_id_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_id_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             IdSelector { span, text } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
+                        self::fields::IdSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(text, visitor)
+                let text = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::IdSelector(
+                        self::fields::IdSelectorField::Text,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        text,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                IdSelector { span, text }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Ident {
-    #[doc = "Calls [VisitAll`::visit_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ident {
+    #[doc = "Calls [FoldAstPath`::fold_ident`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ident(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Ident { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Ident(self::fields::IdentField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Ident { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportConditions {
-    #[doc = "Calls [VisitAll`::visit_import_conditions`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_conditions(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportConditions {
+    #[doc = "Calls [FoldAstPath`::fold_import_conditions`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_conditions(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportConditions {
                 span,
                 supports,
                 media,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
+                        self::fields::ImportConditionsField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Function>> as VisitAllWith<V>>::visit_with(supports, visitor)
+                let supports = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
+                        self::fields::ImportConditionsField::Supports,
+                    ));
+                    <Option<Box<Function>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        supports,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<MediaQueryList>> as VisitAllWith<V>>::visit_with(media, visitor)
+                let media = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportConditions(
+                        self::fields::ImportConditionsField::Media,
+                    ));
+                    <Option<Box<MediaQueryList>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        media,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportConditions {
+                    span,
+                    supports,
+                    media,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportHref {
-    #[doc = "Calls [VisitAll`::visit_import_href`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_href(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportHref {
+    #[doc = "Calls [FoldAstPath`::fold_import_href`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_href(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportHref::Url { 0: _field_0 } => {
-                <Url as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
+                    self::fields::ImportHrefField::Url,
+                ));
+                let _field_0 = <Url as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ImportHref::Url { 0: _field_0 }
             }
             ImportHref::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportHref(
+                    self::fields::ImportHrefField::Str,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ImportHref::Str { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportLayerName {
-    #[doc = "Calls [VisitAll`::visit_import_layer_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_layer_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportLayerName {
+    #[doc = "Calls [FoldAstPath`::fold_import_layer_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_layer_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportLayerName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
+                    self::fields::ImportLayerNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ImportLayerName::Ident { 0: _field_0 }
             }
             ImportLayerName::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportLayerName(
+                    self::fields::ImportLayerNameField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ImportLayerName::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportPrelude {
-    #[doc = "Calls [VisitAll`::visit_import_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportPrelude {
+    #[doc = "Calls [FoldAstPath`::fold_import_prelude`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportPrelude {
                 span,
@@ -119023,502 +102062,1046 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportPrelude {
                 layer_name,
                 import_conditions,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<ImportHref> as VisitAllWith<V>>::visit_with(href, visitor)
+                let href = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::Href,
+                    ));
+                    <Box<ImportHref> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        href,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<ImportLayerName>> as VisitAllWith<V>>::visit_with(
-                        layer_name, visitor,
+                let layer_name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::LayerName,
+                    ));
+                    <Option<Box<ImportLayerName>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        layer_name,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Option<Box<ImportConditions>> as VisitAllWith<V>>::visit_with(
+                let import_conditions = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportPrelude(
+                        self::fields::ImportPreludeField::ImportConditions,
+                    ));
+                    <Option<Box<ImportConditions>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         import_conditions,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                ImportPrelude {
+                    span,
+                    href,
+                    layer_name,
+                    import_conditions,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportantFlag {
-    #[doc = "Calls [VisitAll`::visit_important_flag`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_important_flag(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportantFlag {
+    #[doc = "Calls [FoldAstPath`::fold_important_flag`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_important_flag(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportantFlag { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
+                        self::fields::ImportantFlagField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportantFlag(
+                        self::fields::ImportantFlagField::Value,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportantFlag { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Integer {
-    #[doc = "Calls [VisitAll`::visit_integer`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_integer(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Integer {
+    #[doc = "Calls [FoldAstPath`::fold_integer`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_integer(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Integer { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Integer(self::fields::IntegerField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Integer { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for KeyframeBlock {
-    #[doc = "Calls [VisitAll`::visit_keyframe_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_keyframe_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframeBlock {
+    #[doc = "Calls [FoldAstPath`::fold_keyframe_block`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_keyframe_block(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             KeyframeBlock {
                 span,
                 prelude,
                 block,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
+                        self::fields::KeyframeBlockField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<KeyframeSelector> as VisitAllWith<V>>::visit_with(prelude, visitor)
+                let prelude = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
+                        self::fields::KeyframeBlockField::Prelude(usize::MAX),
+                    ));
+                    <Vec<KeyframeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SimpleBlock as VisitAllWith<V>>::visit_with(block, visitor)
+                let block = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeBlock(
+                        self::fields::KeyframeBlockField::Block,
+                    ));
+                    <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                KeyframeBlock {
+                    span,
+                    prelude,
+                    block,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for KeyframeSelector {
-    #[doc = "Calls [VisitAll`::visit_keyframe_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_keyframe_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframeSelector {
+    #[doc = "Calls [FoldAstPath`::fold_keyframe_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_keyframe_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             KeyframeSelector::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
+                    self::fields::KeyframeSelectorField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                KeyframeSelector::Ident { 0: _field_0 }
             }
             KeyframeSelector::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframeSelector(
+                    self::fields::KeyframeSelectorField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                KeyframeSelector::Percentage { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for KeyframesName {
-    #[doc = "Calls [VisitAll`::visit_keyframes_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_keyframes_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframesName {
+    #[doc = "Calls [FoldAstPath`::fold_keyframes_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_keyframes_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             KeyframesName::CustomIdent { 0: _field_0 } => {
-                <Box<CustomIdent> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::CustomIdent,
+                ));
+                let _field_0 = <Box<CustomIdent> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                KeyframesName::CustomIdent { 0: _field_0 }
             }
             KeyframesName::Str { 0: _field_0 } => {
-                <Box<Str> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::Str,
+                ));
+                let _field_0 = <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                KeyframesName::Str { 0: _field_0 }
             }
             KeyframesName::PseudoPrefix { 0: _field_0 } => {
-                <Box<KeyframesPseudoPrefix> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::PseudoPrefix,
+                ));
+                let _field_0 =
+                    <Box<KeyframesPseudoPrefix> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                KeyframesName::PseudoPrefix { 0: _field_0 }
             }
             KeyframesName::PseudoFunction { 0: _field_0 } => {
-                <Box<KeyframesPseudoFunction> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyframesName(
+                    self::fields::KeyframesNameField::PseudoFunction,
+                ));
+                let _field_0 =
+                    <Box<KeyframesPseudoFunction> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                KeyframesName::PseudoFunction { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for KeyframesPseudoFunction {
-    #[doc = "Calls [VisitAll`::visit_keyframes_pseudo_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_keyframes_pseudo_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframesPseudoFunction {
+    #[doc = "Calls [FoldAstPath`::fold_keyframes_pseudo_function`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_keyframes_pseudo_function(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             KeyframesPseudoFunction { span, pseudo, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
+                            self::fields::KeyframesPseudoFunctionField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(pseudo, visitor)
+                let pseudo = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
+                            self::fields::KeyframesPseudoFunctionField::Pseudo,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        pseudo,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <KeyframesName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoFunction(
+                            self::fields::KeyframesPseudoFunctionField::Name,
+                        ));
+                    <KeyframesName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                KeyframesPseudoFunction { span, pseudo, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for KeyframesPseudoPrefix {
-    #[doc = "Calls [VisitAll`::visit_keyframes_pseudo_prefix`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_keyframes_pseudo_prefix(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyframesPseudoPrefix {
+    #[doc = "Calls [FoldAstPath`::fold_keyframes_pseudo_prefix`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_keyframes_pseudo_prefix(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             KeyframesPseudoPrefix { span, pseudo, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
+                            self::fields::KeyframesPseudoPrefixField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(pseudo, visitor)
+                let pseudo = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
+                            self::fields::KeyframesPseudoPrefixField::Pseudo,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        pseudo,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <KeyframesName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::KeyframesPseudoPrefix(
+                            self::fields::KeyframesPseudoPrefixField::Name,
+                        ));
+                    <KeyframesName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                KeyframesPseudoPrefix { span, pseudo, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for LayerName {
-    #[doc = "Calls [VisitAll`::visit_layer_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_layer_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LayerName {
+    #[doc = "Calls [FoldAstPath`::fold_layer_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_layer_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             LayerName { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::LayerName(self::fields::LayerNameField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Ident> as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerName(
+                        self::fields::LayerNameField::Name(usize::MAX),
+                    ));
+                    <Vec<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                LayerName { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for LayerNameList {
-    #[doc = "Calls [VisitAll`::visit_layer_name_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_layer_name_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LayerNameList {
+    #[doc = "Calls [FoldAstPath`::fold_layer_name_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_layer_name_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             LayerNameList { span, name_list } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
+                        self::fields::LayerNameListField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<LayerName> as VisitAllWith<V>>::visit_with(name_list, visitor)
+                let name_list = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerNameList(
+                        self::fields::LayerNameListField::NameList(usize::MAX),
+                    ));
+                    <Vec<LayerName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name_list,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                LayerNameList { span, name_list }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for LayerPrelude {
-    #[doc = "Calls [VisitAll`::visit_layer_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_layer_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LayerPrelude {
+    #[doc = "Calls [FoldAstPath`::fold_layer_prelude`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_layer_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             LayerPrelude::Name { 0: _field_0 } => {
-                <LayerName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
+                    self::fields::LayerPreludeField::Name,
+                ));
+                let _field_0 = <LayerName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                LayerPrelude::Name { 0: _field_0 }
             }
             LayerPrelude::NameList { 0: _field_0 } => {
-                <LayerNameList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LayerPrelude(
+                    self::fields::LayerPreludeField::NameList,
+                ));
+                let _field_0 = <LayerNameList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                LayerPrelude::NameList { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Length {
-    #[doc = "Calls [VisitAll`::visit_length`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_length(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Length {
+    #[doc = "Calls [FoldAstPath`::fold_length`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_length(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Length { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Length(self::fields::LengthField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Length(self::fields::LengthField::Value));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Length(self::fields::LengthField::Unit));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Length { span, value, unit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for LengthPercentage {
-    #[doc = "Calls [VisitAll`::visit_length_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_length_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LengthPercentage {
+    #[doc = "Calls [FoldAstPath`::fold_length_percentage`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_length_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             LengthPercentage::Length { 0: _field_0 } => {
-                <Length as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
+                    self::fields::LengthPercentageField::Length,
+                ));
+                let _field_0 = <Length as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                LengthPercentage::Length { 0: _field_0 }
             }
             LengthPercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::LengthPercentage(
+                    self::fields::LengthPercentageField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                LengthPercentage::Percentage { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ListOfComponentValues {
-    #[doc = "Calls [VisitAll`::visit_list_of_component_values`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_list_of_component_values(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ListOfComponentValues {
+    #[doc = "Calls [FoldAstPath`::fold_list_of_component_values`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_list_of_component_values(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ListOfComponentValues { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
+                            self::fields::ListOfComponentValuesField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ComponentValue> as VisitAllWith<V>>::visit_with(children, visitor)
+                let children = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ListOfComponentValues(
+                            self::fields::ListOfComponentValuesField::Children(usize::MAX),
+                        ));
+                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ListOfComponentValues { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaAnd {
-    #[doc = "Calls [VisitAll`::visit_media_and`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaAnd {
+    #[doc = "Calls [FoldAstPath`::fold_media_and`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_and(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaAnd {
                 span,
                 keyword,
                 condition,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaAnd(self::fields::MediaAndField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
+                        self::fields::MediaAndField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaInParens as VisitAllWith<V>>::visit_with(condition, visitor)
+                let condition = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaAnd(
+                        self::fields::MediaAndField::Condition,
+                    ));
+                    <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaAnd {
+                    span,
+                    keyword,
+                    condition,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaCondition {
-    #[doc = "Calls [VisitAll`::visit_media_condition`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaCondition {
+    #[doc = "Calls [FoldAstPath`::fold_media_condition`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_condition(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaCondition { span, conditions } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
+                        self::fields::MediaConditionField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<MediaConditionAllType> as VisitAllWith<V>>::visit_with(conditions, visitor)
+                let conditions = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaCondition(
+                        self::fields::MediaConditionField::Conditions(usize::MAX),
+                    ));
+                    <Vec<MediaConditionAllType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaCondition { span, conditions }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaConditionAllType {
-    #[doc = "Calls [VisitAll`::visit_media_condition_all_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_condition_all_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionAllType {
+    #[doc = "Calls [FoldAstPath`::fold_media_condition_all_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_condition_all_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaConditionAllType::Not { 0: _field_0 } => {
-                <MediaNot as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::Not,
+                ));
+                let _field_0 = <MediaNot as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionAllType::Not { 0: _field_0 }
             }
             MediaConditionAllType::And { 0: _field_0 } => {
-                <MediaAnd as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::And,
+                ));
+                let _field_0 = <MediaAnd as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionAllType::And { 0: _field_0 }
             }
             MediaConditionAllType::Or { 0: _field_0 } => {
-                <MediaOr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::Or,
+                ));
+                let _field_0 = <MediaOr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionAllType::Or { 0: _field_0 }
             }
             MediaConditionAllType::MediaInParens { 0: _field_0 } => {
-                <MediaInParens as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionAllType(
+                    self::fields::MediaConditionAllTypeField::MediaInParens,
+                ));
+                let _field_0 = <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionAllType::MediaInParens { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaConditionType {
-    #[doc = "Calls [VisitAll`::visit_media_condition_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_condition_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionType {
+    #[doc = "Calls [FoldAstPath`::fold_media_condition_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_condition_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaConditionType::All { 0: _field_0 } => {
-                <MediaCondition as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
+                    self::fields::MediaConditionTypeField::All,
+                ));
+                let _field_0 = <MediaCondition as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionType::All { 0: _field_0 }
             }
             MediaConditionType::WithoutOr { 0: _field_0 } => {
-                <MediaConditionWithoutOr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaConditionType(
+                    self::fields::MediaConditionTypeField::WithoutOr,
+                ));
+                let _field_0 = <MediaConditionWithoutOr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionType::WithoutOr { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaConditionWithoutOr {
-    #[doc = "Calls [VisitAll`::visit_media_condition_without_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_condition_without_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionWithoutOr {
+    #[doc = "Calls [FoldAstPath`::fold_media_condition_without_or`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_condition_without_or(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaConditionWithoutOr { span, conditions } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
+                            self::fields::MediaConditionWithoutOrField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<MediaConditionWithoutOrType> as VisitAllWith<V>>::visit_with(
-                        conditions, visitor,
+                let conditions = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaConditionWithoutOr(
+                            self::fields::MediaConditionWithoutOrField::Conditions(usize::MAX),
+                        ));
+                    <Vec<MediaConditionWithoutOrType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                MediaConditionWithoutOr { span, conditions }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaConditionWithoutOrType {
-    #[doc = "Calls [VisitAll`::visit_media_condition_without_or_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_condition_without_or_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaConditionWithoutOrType {
+    #[doc = "Calls [FoldAstPath`::fold_media_condition_without_or_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_condition_without_or_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaConditionWithoutOrType::Not { 0: _field_0 } => {
-                <MediaNot as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
+                        self::fields::MediaConditionWithoutOrTypeField::Not,
+                    ));
+                let _field_0 = <MediaNot as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionWithoutOrType::Not { 0: _field_0 }
             }
             MediaConditionWithoutOrType::And { 0: _field_0 } => {
-                <MediaAnd as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
+                        self::fields::MediaConditionWithoutOrTypeField::And,
+                    ));
+                let _field_0 = <MediaAnd as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionWithoutOrType::And { 0: _field_0 }
             }
             MediaConditionWithoutOrType::MediaInParens { 0: _field_0 } => {
-                <MediaInParens as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::MediaConditionWithoutOrType(
+                        self::fields::MediaConditionWithoutOrTypeField::MediaInParens,
+                    ));
+                let _field_0 = <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaConditionWithoutOrType::MediaInParens { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeature {
-    #[doc = "Calls [VisitAll`::visit_media_feature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeature {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaFeature::Plain { 0: _field_0 } => {
-                <MediaFeaturePlain as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::Plain,
+                ));
+                let _field_0 = <MediaFeaturePlain as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeature::Plain { 0: _field_0 }
             }
             MediaFeature::Boolean { 0: _field_0 } => {
-                <MediaFeatureBoolean as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::Boolean,
+                ));
+                let _field_0 = <MediaFeatureBoolean as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeature::Boolean { 0: _field_0 }
             }
             MediaFeature::Range { 0: _field_0 } => {
-                <MediaFeatureRange as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::Range,
+                ));
+                let _field_0 = <MediaFeatureRange as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeature::Range { 0: _field_0 }
             }
             MediaFeature::RangeInterval { 0: _field_0 } => {
-                <MediaFeatureRangeInterval as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeature(
+                    self::fields::MediaFeatureField::RangeInterval,
+                ));
+                let _field_0 =
+                    <MediaFeatureRangeInterval as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                MediaFeature::RangeInterval { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureBoolean {
-    #[doc = "Calls [VisitAll`::visit_media_feature_boolean`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature_boolean(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureBoolean {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature_boolean`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature_boolean(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaFeatureBoolean { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
+                        self::fields::MediaFeatureBooleanField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaFeatureName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureBoolean(
+                        self::fields::MediaFeatureBooleanField::Name,
+                    ));
+                    <MediaFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaFeatureBoolean { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureName {
-    #[doc = "Calls [VisitAll`::visit_media_feature_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureName {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaFeatureName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
+                    self::fields::MediaFeatureNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeatureName::Ident { 0: _field_0 }
             }
             MediaFeatureName::ExtensionName { 0: _field_0 } => {
-                <ExtensionName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureName(
+                    self::fields::MediaFeatureNameField::ExtensionName,
+                ));
+                let _field_0 = <ExtensionName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeatureName::ExtensionName { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeaturePlain {
-    #[doc = "Calls [VisitAll`::visit_media_feature_plain`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature_plain(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeaturePlain {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature_plain`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature_plain(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaFeaturePlain { span, name, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
+                        self::fields::MediaFeaturePlainField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaFeatureName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
+                        self::fields::MediaFeaturePlainField::Name,
+                    ));
+                    <MediaFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<MediaFeatureValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeaturePlain(
+                        self::fields::MediaFeaturePlainField::Value,
+                    ));
+                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaFeaturePlain { span, name, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureRange {
-    #[doc = "Calls [VisitAll`::visit_media_feature_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRange {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature_range`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature_range(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaFeatureRange {
                 span,
@@ -119526,47 +103109,83 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureRange {
                 comparison,
                 right,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<MediaFeatureValue> as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Left,
+                    ));
+                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaFeatureRangeComparison as VisitAllWith<V>>::visit_with(
-                        comparison, visitor,
+                let comparison = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Comparison,
+                    ));
+                    <MediaFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
+                        comparison,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Box<MediaFeatureValue> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureRange(
+                        self::fields::MediaFeatureRangeField::Right,
+                    ));
+                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaFeatureRange {
+                    span,
+                    left,
+                    comparison,
+                    right,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureRangeComparison {
-    #[doc = "Calls [VisitAll`::visit_media_feature_range_comparison`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature_range_comparison(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRangeComparison {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature_range_comparison`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature_range_comparison(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            MediaFeatureRangeComparison::Lt => {}
-            MediaFeatureRangeComparison::Le => {}
-            MediaFeatureRangeComparison::Gt => {}
-            MediaFeatureRangeComparison::Ge => {}
-            MediaFeatureRangeComparison::Eq => {}
+            MediaFeatureRangeComparison::Lt => MediaFeatureRangeComparison::Lt,
+            MediaFeatureRangeComparison::Le => MediaFeatureRangeComparison::Le,
+            MediaFeatureRangeComparison::Gt => MediaFeatureRangeComparison::Gt,
+            MediaFeatureRangeComparison::Ge => MediaFeatureRangeComparison::Ge,
+            MediaFeatureRangeComparison::Eq => MediaFeatureRangeComparison::Eq,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureRangeInterval {
-    #[doc = "Calls [VisitAll`::visit_media_feature_range_interval`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature_range_interval(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureRangeInterval {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature_range_interval`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature_range_interval(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaFeatureRangeInterval {
                 span,
@@ -119576,139 +103195,312 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureRangeInterval {
                 right_comparison,
                 right,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<MediaFeatureValue> as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Left,
+                        ));
+                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaFeatureRangeComparison as VisitAllWith<V>>::visit_with(
+                let left_comparison = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::LeftComparison,
+                        ));
+                    <MediaFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
                         left_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <MediaFeatureName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Name,
+                        ));
+                    <MediaFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaFeatureRangeComparison as VisitAllWith<V>>::visit_with(
+                let right_comparison = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::RightComparison,
+                        ));
+                    <MediaFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
                         right_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Box<MediaFeatureValue> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::MediaFeatureRangeInterval(
+                            self::fields::MediaFeatureRangeIntervalField::Right,
+                        ));
+                    <Box<MediaFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaFeatureRangeInterval {
+                    span,
+                    left,
+                    left_comparison,
+                    name,
+                    right_comparison,
+                    right,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaFeatureValue {
-    #[doc = "Calls [VisitAll`::visit_media_feature_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_feature_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaFeatureValue {
+    #[doc = "Calls [FoldAstPath`::fold_media_feature_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_feature_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaFeatureValue::Number { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Number,
+                ));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeatureValue::Number { 0: _field_0 }
             }
             MediaFeatureValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Dimension,
+                ));
+                let _field_0 = <Dimension as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeatureValue::Dimension { 0: _field_0 }
             }
             MediaFeatureValue::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeatureValue::Ident { 0: _field_0 }
             }
             MediaFeatureValue::Ratio { 0: _field_0 } => {
-                <Ratio as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Ratio,
+                ));
+                let _field_0 = <Ratio as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeatureValue::Ratio { 0: _field_0 }
             }
             MediaFeatureValue::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaFeatureValue(
+                    self::fields::MediaFeatureValueField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaFeatureValue::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaInParens {
-    #[doc = "Calls [VisitAll`::visit_media_in_parens`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaInParens {
+    #[doc = "Calls [FoldAstPath`::fold_media_in_parens`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_in_parens(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaInParens::MediaCondition { 0: _field_0 } => {
-                <MediaCondition as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
+                    self::fields::MediaInParensField::MediaCondition,
+                ));
+                let _field_0 = <MediaCondition as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaInParens::MediaCondition { 0: _field_0 }
             }
             MediaInParens::Feature { 0: _field_0 } => {
-                <Box<MediaFeature> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
+                    self::fields::MediaInParensField::Feature,
+                ));
+                let _field_0 = <Box<MediaFeature> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaInParens::Feature { 0: _field_0 }
             }
             MediaInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaInParens(
+                    self::fields::MediaInParensField::GeneralEnclosed,
+                ));
+                let _field_0 = <GeneralEnclosed as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaInParens::GeneralEnclosed { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaNot {
-    #[doc = "Calls [VisitAll`::visit_media_not`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaNot {
+    #[doc = "Calls [FoldAstPath`::fold_media_not`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_not(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaNot {
                 span,
                 keyword,
                 condition,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaNot(self::fields::MediaNotField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
+                        self::fields::MediaNotField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaInParens as VisitAllWith<V>>::visit_with(condition, visitor)
+                let condition = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaNot(
+                        self::fields::MediaNotField::Condition,
+                    ));
+                    <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaNot {
+                    span,
+                    keyword,
+                    condition,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaOr {
-    #[doc = "Calls [VisitAll`::visit_media_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaOr {
+    #[doc = "Calls [FoldAstPath`::fold_media_or`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_or(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaOr {
                 span,
                 keyword,
                 condition,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::MediaOr(self::fields::MediaOrField::Keyword));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MediaInParens as VisitAllWith<V>>::visit_with(condition, visitor)
+                let condition = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaOr(
+                        self::fields::MediaOrField::Condition,
+                    ));
+                    <MediaInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaOr {
+                    span,
+                    keyword,
+                    condition,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaQuery {
-    #[doc = "Calls [VisitAll`::visit_media_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaQuery {
+    #[doc = "Calls [FoldAstPath`::fold_media_query`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_query(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaQuery {
                 span,
@@ -119717,783 +103509,1627 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaQuery {
                 keyword,
                 condition,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(modifier, visitor)
+                let modifier = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Modifier,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        modifier,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<MediaType> as VisitAllWith<V>>::visit_with(media_type, visitor)
+                let media_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::MediaType,
+                    ));
+                    <Option<MediaType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        media_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<MediaConditionType>> as VisitAllWith<V>>::visit_with(
-                        condition, visitor,
+                let condition = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQuery(
+                        self::fields::MediaQueryField::Condition,
+                    ));
+                    <Option<Box<MediaConditionType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                MediaQuery {
+                    span,
+                    modifier,
+                    media_type,
+                    keyword,
+                    condition,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaQueryList {
-    #[doc = "Calls [VisitAll`::visit_media_query_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_query_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaQueryList {
+    #[doc = "Calls [FoldAstPath`::fold_media_query_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_query_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaQueryList { span, queries } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
+                        self::fields::MediaQueryListField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<MediaQuery> as VisitAllWith<V>>::visit_with(queries, visitor)
+                let queries = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaQueryList(
+                        self::fields::MediaQueryListField::Queries(usize::MAX),
+                    ));
+                    <Vec<MediaQuery> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        queries,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MediaQueryList { span, queries }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MediaType {
-    #[doc = "Calls [VisitAll`::visit_media_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MediaType {
+    #[doc = "Calls [FoldAstPath`::fold_media_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MediaType::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MediaType(
+                    self::fields::MediaTypeField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MediaType::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NamedNamespace {
-    #[doc = "Calls [VisitAll`::visit_named_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_named_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamedNamespace {
+    #[doc = "Calls [FoldAstPath`::fold_named_namespace`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_named_namespace(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             NamedNamespace { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
+                        self::fields::NamedNamespaceField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedNamespace(
+                        self::fields::NamedNamespaceField::Name,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                NamedNamespace { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Namespace {
-    #[doc = "Calls [VisitAll`::visit_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_namespace(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Namespace {
+    #[doc = "Calls [FoldAstPath`::fold_namespace`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_namespace(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Namespace::Named { 0: _field_0 } => {
-                <NamedNamespace as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Namespace(
+                    self::fields::NamespaceField::Named,
+                ));
+                let _field_0 = <NamedNamespace as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Namespace::Named { 0: _field_0 }
             }
             Namespace::Any { 0: _field_0 } => {
-                <AnyNamespace as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Namespace(self::fields::NamespaceField::Any));
+                let _field_0 = <AnyNamespace as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Namespace::Any { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NamespacePrefix {
-    #[doc = "Calls [VisitAll`::visit_namespace_prefix`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_namespace_prefix(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamespacePrefix {
+    #[doc = "Calls [FoldAstPath`::fold_namespace_prefix`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_namespace_prefix(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             NamespacePrefix { span, namespace } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
+                        self::fields::NamespacePrefixField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Namespace> as VisitAllWith<V>>::visit_with(namespace, visitor)
+                let namespace = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrefix(
+                        self::fields::NamespacePrefixField::Namespace,
+                    ));
+                    <Option<Namespace> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        namespace,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                NamespacePrefix { span, namespace }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NamespacePrelude {
-    #[doc = "Calls [VisitAll`::visit_namespace_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_namespace_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamespacePrelude {
+    #[doc = "Calls [FoldAstPath`::fold_namespace_prelude`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_namespace_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             NamespacePrelude { span, prefix, uri } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
+                        self::fields::NamespacePreludeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(prefix, visitor)
+                let prefix = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
+                        self::fields::NamespacePreludeField::Prefix,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<NamespacePreludeUri> as VisitAllWith<V>>::visit_with(uri, visitor)
+                let uri = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePrelude(
+                        self::fields::NamespacePreludeField::Uri,
+                    ));
+                    <Box<NamespacePreludeUri> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        uri,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                NamespacePrelude { span, prefix, uri }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NamespacePreludeUri {
-    #[doc = "Calls [VisitAll`::visit_namespace_prelude_uri`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_namespace_prelude_uri(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamespacePreludeUri {
+    #[doc = "Calls [FoldAstPath`::fold_namespace_prelude_uri`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_namespace_prelude_uri(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             NamespacePreludeUri::Url { 0: _field_0 } => {
-                <Url as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
+                    self::fields::NamespacePreludeUriField::Url,
+                ));
+                let _field_0 = <Url as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                NamespacePreludeUri::Url { 0: _field_0 }
             }
             NamespacePreludeUri::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::NamespacePreludeUri(
+                    self::fields::NamespacePreludeUriField::Str,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                NamespacePreludeUri::Str { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NestingSelector {
-    #[doc = "Calls [VisitAll`::visit_nesting_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_nesting_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NestingSelector {
+    #[doc = "Calls [FoldAstPath`::fold_nesting_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_nesting_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             NestingSelector { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NestingSelector(
+                        self::fields::NestingSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                NestingSelector { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Number {
-    #[doc = "Calls [VisitAll`::visit_number`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_number(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Number {
+    #[doc = "Calls [FoldAstPath`::fold_number`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_number(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Number { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Number { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NumberType {
-    #[doc = "Calls [VisitAll`::visit_number_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_number_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NumberType {
+    #[doc = "Calls [FoldAstPath`::fold_number_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_number_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            NumberType::Integer => {}
-            NumberType::Number => {}
+            NumberType::Integer => NumberType::Integer,
+            NumberType::Number => NumberType::Number,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PageSelector {
-    #[doc = "Calls [VisitAll`::visit_page_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_page_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelector {
+    #[doc = "Calls [FoldAstPath`::fold_page_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_page_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PageSelector {
                 span,
                 page_type,
                 pseudos,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
+                        self::fields::PageSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<PageSelectorType> as VisitAllWith<V>>::visit_with(page_type, visitor)
+                let page_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
+                        self::fields::PageSelectorField::PageType,
+                    ));
+                    <Option<PageSelectorType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        page_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Vec<PageSelectorPseudo>> as VisitAllWith<V>>::visit_with(
-                        pseudos, visitor,
+                let pseudos = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelector(
+                        self::fields::PageSelectorField::Pseudos(usize::MAX),
+                    ));
+                    <Option<Vec<PageSelectorPseudo>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        pseudos,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                PageSelector {
+                    span,
+                    page_type,
+                    pseudos,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PageSelectorList {
-    #[doc = "Calls [VisitAll`::visit_page_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_page_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelectorList {
+    #[doc = "Calls [FoldAstPath`::fold_page_selector_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_page_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PageSelectorList { span, selectors } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
+                        self::fields::PageSelectorListField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<PageSelector> as VisitAllWith<V>>::visit_with(selectors, visitor)
+                let selectors = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorList(
+                        self::fields::PageSelectorListField::Selectors(usize::MAX),
+                    ));
+                    <Vec<PageSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        selectors,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                PageSelectorList { span, selectors }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PageSelectorPseudo {
-    #[doc = "Calls [VisitAll`::visit_page_selector_pseudo`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_page_selector_pseudo(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelectorPseudo {
+    #[doc = "Calls [FoldAstPath`::fold_page_selector_pseudo`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_page_selector_pseudo(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PageSelectorPseudo { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
+                        self::fields::PageSelectorPseudoField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorPseudo(
+                        self::fields::PageSelectorPseudoField::Value,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                PageSelectorPseudo { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PageSelectorType {
-    #[doc = "Calls [VisitAll`::visit_page_selector_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_page_selector_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PageSelectorType {
+    #[doc = "Calls [FoldAstPath`::fold_page_selector_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_page_selector_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PageSelectorType { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
+                        self::fields::PageSelectorTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PageSelectorType(
+                        self::fields::PageSelectorTypeField::Value,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                PageSelectorType { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Percentage {
-    #[doc = "Calls [VisitAll`::visit_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Percentage {
+    #[doc = "Calls [FoldAstPath`::fold_percentage`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Percentage { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
+                        self::fields::PercentageField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Percentage(
+                        self::fields::PercentageField::Value,
+                    ));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Percentage { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PseudoClassSelector {
-    #[doc = "Calls [VisitAll`::visit_pseudo_class_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pseudo_class_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoClassSelector {
+    #[doc = "Calls [FoldAstPath`::fold_pseudo_class_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pseudo_class_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PseudoClassSelector {
                 span,
                 name,
                 children,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(name, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
+                        self::fields::PseudoClassSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Vec<PseudoClassSelectorChildren>> as VisitAllWith<V>>::visit_with(
-                        children, visitor,
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
+                        self::fields::PseudoClassSelectorField::Name,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let children = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PseudoClassSelector(
+                        self::fields::PseudoClassSelectorField::Children(usize::MAX),
+                    ));
+                    < Option < Vec < PseudoClassSelectorChildren > > as FoldWithAstPath < V > > :: fold_with_ast_path (children , visitor , & mut * __ast_path)
+                };
+                PseudoClassSelector {
+                    span,
+                    name,
+                    children,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PseudoClassSelectorChildren {
-    #[doc = "Calls [VisitAll`::visit_pseudo_class_selector_children`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pseudo_class_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoClassSelectorChildren {
+    #[doc = "Calls [FoldAstPath`::fold_pseudo_class_selector_children`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pseudo_class_selector_children(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PseudoClassSelectorChildren::PreservedToken { 0: _field_0 } => {
-                <TokenAndSpan as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::PreservedToken,
+                    ));
+                let _field_0 = <TokenAndSpan as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::PreservedToken { 0: _field_0 }
             }
             PseudoClassSelectorChildren::AnPlusB { 0: _field_0 } => {
-                <AnPlusB as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::AnPlusB,
+                    ));
+                let _field_0 = <AnPlusB as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::AnPlusB { 0: _field_0 }
             }
             PseudoClassSelectorChildren::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::Ident,
+                    ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::Ident { 0: _field_0 }
             }
             PseudoClassSelectorChildren::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::Str,
+                    ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::Str { 0: _field_0 }
             }
             PseudoClassSelectorChildren::Delimiter { 0: _field_0 } => {
-                <Delimiter as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::Delimiter,
+                    ));
+                let _field_0 = <Delimiter as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::Delimiter { 0: _field_0 }
             }
             PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 } => {
-                <ComplexSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::ComplexSelector,
+                    ));
+                let _field_0 = <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::ComplexSelector { 0: _field_0 }
             }
             PseudoClassSelectorChildren::SelectorList { 0: _field_0 } => {
-                <SelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::SelectorList,
+                    ));
+                let _field_0 = <SelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::SelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 } => {
-                <ForgivingSelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::ForgivingSelectorList,
+                    ));
+                let _field_0 = <ForgivingSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::ForgivingSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 } => {
-                <CompoundSelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::CompoundSelectorList,
+                    ));
+                let _field_0 = <CompoundSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::CompoundSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 } => {
-                <RelativeSelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::RelativeSelectorList,
+                    ));
+                let _field_0 = <RelativeSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::RelativeSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 } => {
-                <ForgivingRelativeSelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PseudoClassSelectorChildren(
+                    self::fields::PseudoClassSelectorChildrenField::ForgivingRelativeSelectorList,
+                ));
+                let _field_0 =
+                    <ForgivingRelativeSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                PseudoClassSelectorChildren::ForgivingRelativeSelectorList { 0: _field_0 }
             }
             PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoClassSelectorChildren(
+                        self::fields::PseudoClassSelectorChildrenField::CompoundSelector,
+                    ));
+                let _field_0 = <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoClassSelectorChildren::CompoundSelector { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PseudoElementSelector {
-    #[doc = "Calls [VisitAll`::visit_pseudo_element_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pseudo_element_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoElementSelector {
+    #[doc = "Calls [FoldAstPath`::fold_pseudo_element_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pseudo_element_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PseudoElementSelector {
                 span,
                 name,
                 children,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(name, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
+                            self::fields::PseudoElementSelectorField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Vec<PseudoElementSelectorChildren>> as VisitAllWith<V>>::visit_with(
-                        children, visitor,
+                let name = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
+                            self::fields::PseudoElementSelectorField::Name,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let children = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::PseudoElementSelector(
+                            self::fields::PseudoElementSelectorField::Children(usize::MAX),
+                        ));
+                    < Option < Vec < PseudoElementSelectorChildren > > as FoldWithAstPath < V > > :: fold_with_ast_path (children , visitor , & mut * __ast_path)
+                };
+                PseudoElementSelector {
+                    span,
+                    name,
+                    children,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PseudoElementSelectorChildren {
-    #[doc = "Calls [VisitAll`::visit_pseudo_element_selector_children`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pseudo_element_selector_children(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PseudoElementSelectorChildren {
+    #[doc = "Calls [FoldAstPath`::fold_pseudo_element_selector_children`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pseudo_element_selector_children(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PseudoElementSelectorChildren::PreservedToken { 0: _field_0 } => {
-                <TokenAndSpan as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::PreservedToken,
+                    ));
+                let _field_0 = <TokenAndSpan as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoElementSelectorChildren::PreservedToken { 0: _field_0 }
             }
             PseudoElementSelectorChildren::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::Ident,
+                    ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoElementSelectorChildren::Ident { 0: _field_0 }
             }
             PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 } => {
-                <CompoundSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::CompoundSelector,
+                    ));
+                let _field_0 = <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoElementSelectorChildren::CompoundSelector { 0: _field_0 }
             }
             PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 } => {
-                <CustomHighlightName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::PseudoElementSelectorChildren(
+                        self::fields::PseudoElementSelectorChildrenField::CustomHighlightName,
+                    ));
+                let _field_0 = <CustomHighlightName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PseudoElementSelectorChildren::CustomHighlightName { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for QualifiedRule {
-    #[doc = "Calls [VisitAll`::visit_qualified_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_qualified_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for QualifiedRule {
+    #[doc = "Calls [FoldAstPath`::fold_qualified_rule`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_qualified_rule(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             QualifiedRule {
                 span,
                 prelude,
                 block,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
+                        self::fields::QualifiedRuleField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <QualifiedRulePrelude as VisitAllWith<V>>::visit_with(prelude, visitor)
+                let prelude = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
+                        self::fields::QualifiedRuleField::Prelude,
+                    ));
+                    <QualifiedRulePrelude as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prelude,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SimpleBlock as VisitAllWith<V>>::visit_with(block, visitor)
+                let block = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRule(
+                        self::fields::QualifiedRuleField::Block,
+                    ));
+                    <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                QualifiedRule {
+                    span,
+                    prelude,
+                    block,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for QualifiedRulePrelude {
-    #[doc = "Calls [VisitAll`::visit_qualified_rule_prelude`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_qualified_rule_prelude(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for QualifiedRulePrelude {
+    #[doc = "Calls [FoldAstPath`::fold_qualified_rule_prelude`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_qualified_rule_prelude(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             QualifiedRulePrelude::SelectorList { 0: _field_0 } => {
-                <SelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
+                    self::fields::QualifiedRulePreludeField::SelectorList,
+                ));
+                let _field_0 = <SelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                QualifiedRulePrelude::SelectorList { 0: _field_0 }
             }
             QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 } => {
-                <RelativeSelectorList as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
+                    self::fields::QualifiedRulePreludeField::RelativeSelectorList,
+                ));
+                let _field_0 = <RelativeSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                QualifiedRulePrelude::RelativeSelectorList { 0: _field_0 }
             }
             QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 } => {
-                <ListOfComponentValues as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QualifiedRulePrelude(
+                    self::fields::QualifiedRulePreludeField::ListOfComponentValues,
+                ));
+                let _field_0 = <ListOfComponentValues as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                QualifiedRulePrelude::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for QueryInParens {
-    #[doc = "Calls [VisitAll`::visit_query_in_parens`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_query_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for QueryInParens {
+    #[doc = "Calls [FoldAstPath`::fold_query_in_parens`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_query_in_parens(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             QueryInParens::ContainerQuery { 0: _field_0 } => {
-                <Box<ContainerQuery> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
+                    self::fields::QueryInParensField::ContainerQuery,
+                ));
+                let _field_0 = <Box<ContainerQuery> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                QueryInParens::ContainerQuery { 0: _field_0 }
             }
             QueryInParens::SizeFeature { 0: _field_0 } => {
-                <SizeFeature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
+                    self::fields::QueryInParensField::SizeFeature,
+                ));
+                let _field_0 = <SizeFeature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                QueryInParens::SizeFeature { 0: _field_0 }
             }
             QueryInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::QueryInParens(
+                    self::fields::QueryInParensField::GeneralEnclosed,
+                ));
+                let _field_0 = <GeneralEnclosed as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                QueryInParens::GeneralEnclosed { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Ratio {
-    #[doc = "Calls [VisitAll`::visit_ratio`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ratio(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ratio {
+    #[doc = "Calls [FoldAstPath`::fold_ratio`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ratio(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Ratio { span, left, right } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ratio(self::fields::RatioField::Left));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Number> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Ratio(self::fields::RatioField::Right));
+                    <Option<Number> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Ratio { span, left, right }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for RelativeSelector {
-    #[doc = "Calls [VisitAll`::visit_relative_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_relative_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RelativeSelector {
+    #[doc = "Calls [FoldAstPath`::fold_relative_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_relative_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             RelativeSelector {
                 span,
                 combinator,
                 selector,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
+                        self::fields::RelativeSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Combinator> as VisitAllWith<V>>::visit_with(combinator, visitor)
+                let combinator = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
+                        self::fields::RelativeSelectorField::Combinator,
+                    ));
+                    <Option<Combinator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        combinator,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ComplexSelector as VisitAllWith<V>>::visit_with(selector, visitor)
+                let selector = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RelativeSelector(
+                        self::fields::RelativeSelectorField::Selector,
+                    ));
+                    <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                        selector,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                RelativeSelector {
+                    span,
+                    combinator,
+                    selector,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for RelativeSelectorList {
-    #[doc = "Calls [VisitAll`::visit_relative_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_relative_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RelativeSelectorList {
+    #[doc = "Calls [FoldAstPath`::fold_relative_selector_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_relative_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             RelativeSelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
+                            self::fields::RelativeSelectorListField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<RelativeSelector> as VisitAllWith<V>>::visit_with(children, visitor)
+                let children = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::RelativeSelectorList(
+                            self::fields::RelativeSelectorListField::Children(usize::MAX),
+                        ));
+                    <Vec<RelativeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                RelativeSelectorList { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Resolution {
-    #[doc = "Calls [VisitAll`::visit_resolution`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_resolution(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Resolution {
+    #[doc = "Calls [FoldAstPath`::fold_resolution`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_resolution(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Resolution { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
+                        self::fields::ResolutionField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
+                        self::fields::ResolutionField::Value,
+                    ));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Resolution(
+                        self::fields::ResolutionField::Unit,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Resolution { span, value, unit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Rule {
-    #[doc = "Calls [VisitAll`::visit_rule`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_rule(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Rule {
+    #[doc = "Calls [FoldAstPath`::fold_rule`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_rule(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Rule::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Rule(self::fields::RuleField::QualifiedRule));
+                let _field_0 = <Box<QualifiedRule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Rule::QualifiedRule { 0: _field_0 }
             }
             Rule::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Rule(self::fields::RuleField::AtRule));
+                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Rule::AtRule { 0: _field_0 }
             }
             Rule::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Rule(
+                    self::fields::RuleField::ListOfComponentValues,
+                ));
+                let _field_0 =
+                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                Rule::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ScopeRange {
-    #[doc = "Calls [VisitAll`::visit_scope_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_scope_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ScopeRange {
+    #[doc = "Calls [FoldAstPath`::fold_scope_range`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_scope_range(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ScopeRange {
                 span,
                 scope_start,
                 scope_end,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
+                        self::fields::ScopeRangeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<ForgivingSelectorList> as VisitAllWith<V>>::visit_with(
+                let scope_start = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
+                        self::fields::ScopeRangeField::ScopeStart,
+                    ));
+                    <Option<ForgivingSelectorList> as FoldWithAstPath<V>>::fold_with_ast_path(
                         scope_start,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Option<ForgivingSelectorList> as VisitAllWith<V>>::visit_with(
-                        scope_end, visitor,
+                let scope_end = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ScopeRange(
+                        self::fields::ScopeRangeField::ScopeEnd,
+                    ));
+                    <Option<ForgivingSelectorList> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        scope_end,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                ScopeRange {
+                    span,
+                    scope_start,
+                    scope_end,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SelectorList {
-    #[doc = "Calls [VisitAll`::visit_selector_list`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_selector_list(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SelectorList {
+    #[doc = "Calls [FoldAstPath`::fold_selector_list`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_selector_list(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SelectorList { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
+                        self::fields::SelectorListField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ComplexSelector> as VisitAllWith<V>>::visit_with(children, visitor)
+                let children = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SelectorList(
+                        self::fields::SelectorListField::Children(usize::MAX),
+                    ));
+                    <Vec<ComplexSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SelectorList { span, children }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SequenceOfCustomIdents {
-    #[doc = "Calls [VisitAll`::visit_sequence_of_custom_idents`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_sequence_of_custom_idents(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SequenceOfCustomIdents {
+    #[doc = "Calls [FoldAstPath`::fold_sequence_of_custom_idents`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_sequence_of_custom_idents(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SequenceOfCustomIdents { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
+                            self::fields::SequenceOfCustomIdentsField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<CustomIdent> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SequenceOfCustomIdents(
+                            self::fields::SequenceOfCustomIdentsField::Value(usize::MAX),
+                        ));
+                    <Vec<CustomIdent> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SequenceOfCustomIdents { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SimpleBlock {
-    #[doc = "Calls [VisitAll`::visit_simple_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_simple_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SimpleBlock {
+    #[doc = "Calls [FoldAstPath`::fold_simple_block`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_simple_block(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SimpleBlock { span, name, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
+                        self::fields::SimpleBlockField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TokenAndSpan as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
+                        self::fields::SimpleBlockField::Name,
+                    ));
+                    <TokenAndSpan as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ComponentValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleBlock(
+                        self::fields::SimpleBlockField::Value(usize::MAX),
+                    ));
+                    <Vec<ComponentValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SimpleBlock { span, name, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeature {
-    #[doc = "Calls [VisitAll`::visit_size_feature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeature {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SizeFeature::Plain { 0: _field_0 } => {
-                <SizeFeaturePlain as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::Plain,
+                ));
+                let _field_0 = <SizeFeaturePlain as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeature::Plain { 0: _field_0 }
             }
             SizeFeature::Boolean { 0: _field_0 } => {
-                <SizeFeatureBoolean as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::Boolean,
+                ));
+                let _field_0 = <SizeFeatureBoolean as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeature::Boolean { 0: _field_0 }
             }
             SizeFeature::Range { 0: _field_0 } => {
-                <SizeFeatureRange as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::Range,
+                ));
+                let _field_0 = <SizeFeatureRange as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeature::Range { 0: _field_0 }
             }
             SizeFeature::RangeInterval { 0: _field_0 } => {
-                <SizeFeatureRangeInterval as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeature(
+                    self::fields::SizeFeatureField::RangeInterval,
+                ));
+                let _field_0 = <SizeFeatureRangeInterval as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeature::RangeInterval { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureBoolean {
-    #[doc = "Calls [VisitAll`::visit_size_feature_boolean`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature_boolean(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureBoolean {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature_boolean`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature_boolean(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SizeFeatureBoolean { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
+                        self::fields::SizeFeatureBooleanField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SizeFeatureName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureBoolean(
+                        self::fields::SizeFeatureBooleanField::Name,
+                    ));
+                    <SizeFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SizeFeatureBoolean { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureName {
-    #[doc = "Calls [VisitAll`::visit_size_feature_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureName {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SizeFeatureName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureName(
+                    self::fields::SizeFeatureNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeatureName::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeaturePlain {
-    #[doc = "Calls [VisitAll`::visit_size_feature_plain`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature_plain(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeaturePlain {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature_plain`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature_plain(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SizeFeaturePlain { span, name, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
+                        self::fields::SizeFeaturePlainField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SizeFeatureName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
+                        self::fields::SizeFeaturePlainField::Name,
+                    ));
+                    <SizeFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<SizeFeatureValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeaturePlain(
+                        self::fields::SizeFeaturePlainField::Value,
+                    ));
+                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SizeFeaturePlain { span, name, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureRange {
-    #[doc = "Calls [VisitAll`::visit_size_feature_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRange {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature_range`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature_range(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SizeFeatureRange {
                 span,
@@ -120501,45 +105137,83 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureRange {
                 comparison,
                 right,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<SizeFeatureValue> as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Left,
+                    ));
+                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SizeFeatureRangeComparison as VisitAllWith<V>>::visit_with(comparison, visitor)
+                let comparison = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Comparison,
+                    ));
+                    <SizeFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
+                        comparison,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<SizeFeatureValue> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureRange(
+                        self::fields::SizeFeatureRangeField::Right,
+                    ));
+                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SizeFeatureRange {
+                    span,
+                    left,
+                    comparison,
+                    right,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureRangeComparison {
-    #[doc = "Calls [VisitAll`::visit_size_feature_range_comparison`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature_range_comparison(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRangeComparison {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature_range_comparison`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature_range_comparison(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            SizeFeatureRangeComparison::Lt => {}
-            SizeFeatureRangeComparison::Le => {}
-            SizeFeatureRangeComparison::Gt => {}
-            SizeFeatureRangeComparison::Ge => {}
-            SizeFeatureRangeComparison::Eq => {}
+            SizeFeatureRangeComparison::Lt => SizeFeatureRangeComparison::Lt,
+            SizeFeatureRangeComparison::Le => SizeFeatureRangeComparison::Le,
+            SizeFeatureRangeComparison::Gt => SizeFeatureRangeComparison::Gt,
+            SizeFeatureRangeComparison::Ge => SizeFeatureRangeComparison::Ge,
+            SizeFeatureRangeComparison::Eq => SizeFeatureRangeComparison::Eq,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureRangeInterval {
-    #[doc = "Calls [VisitAll`::visit_size_feature_range_interval`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature_range_interval(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureRangeInterval {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature_range_interval`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature_range_interval(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SizeFeatureRangeInterval {
                 span,
@@ -120549,514 +105223,1151 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureRangeInterval {
                 right_comparison,
                 right,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<SizeFeatureValue> as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Left,
+                        ));
+                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SizeFeatureRangeComparison as VisitAllWith<V>>::visit_with(
+                let left_comparison = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::LeftComparison,
+                        ));
+                    <SizeFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
                         left_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <SizeFeatureName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Name,
+                        ));
+                    <SizeFeatureName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SizeFeatureRangeComparison as VisitAllWith<V>>::visit_with(
+                let right_comparison = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::RightComparison,
+                        ));
+                    <SizeFeatureRangeComparison as FoldWithAstPath<V>>::fold_with_ast_path(
                         right_comparison,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Box<SizeFeatureValue> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::SizeFeatureRangeInterval(
+                            self::fields::SizeFeatureRangeIntervalField::Right,
+                        ));
+                    <Box<SizeFeatureValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SizeFeatureRangeInterval {
+                    span,
+                    left,
+                    left_comparison,
+                    name,
+                    right_comparison,
+                    right,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SizeFeatureValue {
-    #[doc = "Calls [VisitAll`::visit_size_feature_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_size_feature_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SizeFeatureValue {
+    #[doc = "Calls [FoldAstPath`::fold_size_feature_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_size_feature_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SizeFeatureValue::Number { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Number,
+                ));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeatureValue::Number { 0: _field_0 }
             }
             SizeFeatureValue::Dimension { 0: _field_0 } => {
-                <Dimension as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Dimension,
+                ));
+                let _field_0 = <Dimension as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeatureValue::Dimension { 0: _field_0 }
             }
             SizeFeatureValue::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeatureValue::Ident { 0: _field_0 }
             }
             SizeFeatureValue::Ratio { 0: _field_0 } => {
-                <Ratio as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Ratio,
+                ));
+                let _field_0 = <Ratio as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeatureValue::Ratio { 0: _field_0 }
             }
             SizeFeatureValue::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SizeFeatureValue(
+                    self::fields::SizeFeatureValueField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SizeFeatureValue::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Str {
-    #[doc = "Calls [VisitAll`::visit_str`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_str(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Str {
+    #[doc = "Calls [FoldAstPath`::fold_str`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_str(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Str { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Str { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for StyleBlock {
-    #[doc = "Calls [VisitAll`::visit_style_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_style_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for StyleBlock {
+    #[doc = "Calls [FoldAstPath`::fold_style_block`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_style_block(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             StyleBlock::AtRule { 0: _field_0 } => {
-                <Box<AtRule> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::AtRule,
+                ));
+                let _field_0 = <Box<AtRule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                StyleBlock::AtRule { 0: _field_0 }
             }
             StyleBlock::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::Declaration,
+                ));
+                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                StyleBlock::Declaration { 0: _field_0 }
             }
             StyleBlock::QualifiedRule { 0: _field_0 } => {
-                <Box<QualifiedRule> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::QualifiedRule,
+                ));
+                let _field_0 = <Box<QualifiedRule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                StyleBlock::QualifiedRule { 0: _field_0 }
             }
             StyleBlock::ListOfComponentValues { 0: _field_0 } => {
-                <Box<ListOfComponentValues> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::StyleBlock(
+                    self::fields::StyleBlockField::ListOfComponentValues,
+                ));
+                let _field_0 =
+                    <Box<ListOfComponentValues> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                StyleBlock::ListOfComponentValues { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Stylesheet {
-    #[doc = "Calls [VisitAll`::visit_stylesheet`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_stylesheet(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Stylesheet {
+    #[doc = "Calls [FoldAstPath`::fold_stylesheet`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_stylesheet(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Stylesheet { span, rules } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
+                        self::fields::StylesheetField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Rule> as VisitAllWith<V>>::visit_with(rules, visitor)
+                let rules = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Stylesheet(
+                        self::fields::StylesheetField::Rules(usize::MAX),
+                    ));
+                    <Vec<Rule> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        rules,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Stylesheet { span, rules }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SubclassSelector {
-    #[doc = "Calls [VisitAll`::visit_subclass_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_subclass_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SubclassSelector {
+    #[doc = "Calls [FoldAstPath`::fold_subclass_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_subclass_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SubclassSelector::Id { 0: _field_0 } => {
-                <IdSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::Id,
+                ));
+                let _field_0 = <IdSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SubclassSelector::Id { 0: _field_0 }
             }
             SubclassSelector::Class { 0: _field_0 } => {
-                <ClassSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::Class,
+                ));
+                let _field_0 = <ClassSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SubclassSelector::Class { 0: _field_0 }
             }
             SubclassSelector::Attribute { 0: _field_0 } => {
-                <Box<AttributeSelector> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::Attribute,
+                ));
+                let _field_0 = <Box<AttributeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SubclassSelector::Attribute { 0: _field_0 }
             }
             SubclassSelector::PseudoClass { 0: _field_0 } => {
-                <PseudoClassSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::PseudoClass,
+                ));
+                let _field_0 = <PseudoClassSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SubclassSelector::PseudoClass { 0: _field_0 }
             }
             SubclassSelector::PseudoElement { 0: _field_0 } => {
-                <PseudoElementSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SubclassSelector(
+                    self::fields::SubclassSelectorField::PseudoElement,
+                ));
+                let _field_0 = <PseudoElementSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SubclassSelector::PseudoElement { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SupportsAnd {
-    #[doc = "Calls [VisitAll`::visit_supports_and`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_and(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsAnd {
+    #[doc = "Calls [FoldAstPath`::fold_supports_and`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_and(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SupportsAnd {
                 span,
                 keyword,
                 condition,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
+                        self::fields::SupportsAndField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
+                        self::fields::SupportsAndField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<SupportsInParens> as VisitAllWith<V>>::visit_with(condition, visitor)
+                let condition = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsAnd(
+                        self::fields::SupportsAndField::Condition,
+                    ));
+                    <Box<SupportsInParens> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SupportsAnd {
+                    span,
+                    keyword,
+                    condition,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SupportsCondition {
-    #[doc = "Calls [VisitAll`::visit_supports_condition`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_condition(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsCondition {
+    #[doc = "Calls [FoldAstPath`::fold_supports_condition`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_condition(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SupportsCondition { span, conditions } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
+                        self::fields::SupportsConditionField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<SupportsConditionType> as VisitAllWith<V>>::visit_with(conditions, visitor)
+                let conditions = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsCondition(
+                        self::fields::SupportsConditionField::Conditions(usize::MAX),
+                    ));
+                    <Vec<SupportsConditionType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        conditions,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SupportsCondition { span, conditions }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SupportsConditionType {
-    #[doc = "Calls [VisitAll`::visit_supports_condition_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_condition_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsConditionType {
+    #[doc = "Calls [FoldAstPath`::fold_supports_condition_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_condition_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SupportsConditionType::Not { 0: _field_0 } => {
-                <SupportsNot as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::Not,
+                ));
+                let _field_0 = <SupportsNot as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsConditionType::Not { 0: _field_0 }
             }
             SupportsConditionType::And { 0: _field_0 } => {
-                <SupportsAnd as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::And,
+                ));
+                let _field_0 = <SupportsAnd as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsConditionType::And { 0: _field_0 }
             }
             SupportsConditionType::Or { 0: _field_0 } => {
-                <SupportsOr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::Or,
+                ));
+                let _field_0 = <SupportsOr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsConditionType::Or { 0: _field_0 }
             }
             SupportsConditionType::SupportsInParens { 0: _field_0 } => {
-                <SupportsInParens as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsConditionType(
+                    self::fields::SupportsConditionTypeField::SupportsInParens,
+                ));
+                let _field_0 = <SupportsInParens as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsConditionType::SupportsInParens { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SupportsFeature {
-    #[doc = "Calls [VisitAll`::visit_supports_feature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_feature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsFeature {
+    #[doc = "Calls [FoldAstPath`::fold_supports_feature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_feature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SupportsFeature::Declaration { 0: _field_0 } => {
-                <Box<Declaration> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
+                    self::fields::SupportsFeatureField::Declaration,
+                ));
+                let _field_0 = <Box<Declaration> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsFeature::Declaration { 0: _field_0 }
             }
             SupportsFeature::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsFeature(
+                    self::fields::SupportsFeatureField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsFeature::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SupportsInParens {
-    #[doc = "Calls [VisitAll`::visit_supports_in_parens`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_in_parens(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsInParens {
+    #[doc = "Calls [FoldAstPath`::fold_supports_in_parens`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_in_parens(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SupportsInParens::SupportsCondition { 0: _field_0 } => {
-                <SupportsCondition as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
+                    self::fields::SupportsInParensField::SupportsCondition,
+                ));
+                let _field_0 = <SupportsCondition as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsInParens::SupportsCondition { 0: _field_0 }
             }
             SupportsInParens::Feature { 0: _field_0 } => {
-                <SupportsFeature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
+                    self::fields::SupportsInParensField::Feature,
+                ));
+                let _field_0 = <SupportsFeature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsInParens::Feature { 0: _field_0 }
             }
             SupportsInParens::GeneralEnclosed { 0: _field_0 } => {
-                <GeneralEnclosed as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsInParens(
+                    self::fields::SupportsInParensField::GeneralEnclosed,
+                ));
+                let _field_0 = <GeneralEnclosed as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SupportsInParens::GeneralEnclosed { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SupportsNot {
-    #[doc = "Calls [VisitAll`::visit_supports_not`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_not(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsNot {
+    #[doc = "Calls [FoldAstPath`::fold_supports_not`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_not(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SupportsNot {
                 span,
                 keyword,
                 condition,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
+                        self::fields::SupportsNotField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
+                        self::fields::SupportsNotField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<SupportsInParens> as VisitAllWith<V>>::visit_with(condition, visitor)
+                let condition = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsNot(
+                        self::fields::SupportsNotField::Condition,
+                    ));
+                    <Box<SupportsInParens> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SupportsNot {
+                    span,
+                    keyword,
+                    condition,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SupportsOr {
-    #[doc = "Calls [VisitAll`::visit_supports_or`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_or(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SupportsOr {
+    #[doc = "Calls [FoldAstPath`::fold_supports_or`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_or(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SupportsOr {
                 span,
                 keyword,
                 condition,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
+                        self::fields::SupportsOrField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(keyword, visitor)
+                let keyword = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
+                        self::fields::SupportsOrField::Keyword,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        keyword,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<SupportsInParens> as VisitAllWith<V>>::visit_with(condition, visitor)
+                let condition = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SupportsOr(
+                        self::fields::SupportsOrField::Condition,
+                    ));
+                    <Box<SupportsInParens> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        condition,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SupportsOr {
+                    span,
+                    keyword,
+                    condition,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TagNameSelector {
-    #[doc = "Calls [VisitAll`::visit_tag_name_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_tag_name_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TagNameSelector {
+    #[doc = "Calls [FoldAstPath`::fold_tag_name_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_tag_name_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TagNameSelector { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
+                        self::fields::TagNameSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <WqName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TagNameSelector(
+                        self::fields::TagNameSelectorField::Name,
+                    ));
+                    <WqName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TagNameSelector { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Time {
-    #[doc = "Calls [VisitAll`::visit_time`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_time(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Time {
+    #[doc = "Calls [FoldAstPath`::fold_time`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_time(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Time { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Value));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Time(self::fields::TimeField::Unit));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Time { span, value, unit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TimePercentage {
-    #[doc = "Calls [VisitAll`::visit_time_percentage`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_time_percentage(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TimePercentage {
+    #[doc = "Calls [FoldAstPath`::fold_time_percentage`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_time_percentage(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TimePercentage::Time { 0: _field_0 } => {
-                <Time as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
+                    self::fields::TimePercentageField::Time,
+                ));
+                let _field_0 = <Time as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TimePercentage::Time { 0: _field_0 }
             }
             TimePercentage::Percentage { 0: _field_0 } => {
-                <Percentage as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TimePercentage(
+                    self::fields::TimePercentageField::Percentage,
+                ));
+                let _field_0 = <Percentage as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TimePercentage::Percentage { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Token {
-    #[doc = "Calls [VisitAll`::visit_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_token(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Token {
+    #[doc = "Calls [FoldAstPath`::fold_token`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_token(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Token::Ident { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Ident));
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::Ident { value, raw }
             }
             Token::Function { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Function));
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::Function { value, raw }
             }
             Token::AtKeyword { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::AtKeyword));
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::AtKeyword { value, raw }
             }
             Token::Hash { is_id, value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Hash));
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::Hash { is_id, value, raw }
             }
             Token::String { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::String));
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::String { value, raw }
             }
             Token::BadString { raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::BadString));
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::BadString { raw }
             }
             Token::Url { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Url));
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<UrlKeyValue> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <Box<UrlKeyValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::Url { value, raw }
             }
             Token::BadUrl { raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::BadUrl));
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::BadUrl { raw }
+            }
+            Token::Delim { value } => {
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Delim));
+                Token::Delim { value }
             }
-            Token::Delim { value } => {}
             Token::Number {
                 value,
                 raw,
                 type_flag,
             } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Number));
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <NumberType as VisitAllWith<V>>::visit_with(type_flag, visitor)
+                let type_flag = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::TypeFlag));
+                    <NumberType as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_flag,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::Number {
+                    value,
+                    raw,
+                    type_flag,
+                }
             }
             Token::Percentage { value, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::Percentage));
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Token(self::fields::TokenField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::Percentage { value, raw }
             }
             Token::Dimension { 0: _field_0 } => {
-                <Box<DimensionToken> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::Dimension));
+                let _field_0 = <Box<DimensionToken> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Token::Dimension { 0: _field_0 }
             }
             Token::WhiteSpace { value } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Token(self::fields::TokenField::WhiteSpace));
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Token(self::fields::TokenField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Token::WhiteSpace { value }
             }
-            Token::CDO => {}
-            Token::CDC => {}
-            Token::Colon => {}
-            Token::Semi => {}
-            Token::Comma => {}
-            Token::LBracket => {}
-            Token::RBracket => {}
-            Token::LParen => {}
-            Token::RParen => {}
-            Token::LBrace => {}
-            Token::RBrace => {}
+            Token::CDO => Token::CDO,
+            Token::CDC => Token::CDC,
+            Token::Colon => Token::Colon,
+            Token::Semi => Token::Semi,
+            Token::Comma => Token::Comma,
+            Token::LBracket => Token::LBracket,
+            Token::RBracket => Token::RBracket,
+            Token::LParen => Token::LParen,
+            Token::RParen => Token::RParen,
+            Token::LBrace => Token::LBrace,
+            Token::RBrace => Token::RBrace,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TokenAndSpan {
-    #[doc = "Calls [VisitAll`::visit_token_and_span`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_token_and_span(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TokenAndSpan {
+    #[doc = "Calls [FoldAstPath`::fold_token_and_span`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_token_and_span(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TokenAndSpan { span, token } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
+                        self::fields::TokenAndSpanField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Token as VisitAllWith<V>>::visit_with(token, visitor)
+                let token = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TokenAndSpan(
+                        self::fields::TokenAndSpanField::Token,
+                    ));
+                    <Token as FoldWithAstPath<V>>::fold_with_ast_path(
+                        token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TokenAndSpan { span, token }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TypeSelector {
-    #[doc = "Calls [VisitAll`::visit_type_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_type_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TypeSelector {
+    #[doc = "Calls [FoldAstPath`::fold_type_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_type_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TypeSelector::TagName { 0: _field_0 } => {
-                <TagNameSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
+                    self::fields::TypeSelectorField::TagName,
+                ));
+                let _field_0 = <TagNameSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TypeSelector::TagName { 0: _field_0 }
             }
             TypeSelector::Universal { 0: _field_0 } => {
-                <UniversalSelector as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TypeSelector(
+                    self::fields::TypeSelectorField::Universal,
+                ));
+                let _field_0 = <UniversalSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TypeSelector::Universal { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UnicodeRange {
-    #[doc = "Calls [VisitAll`::visit_unicode_range`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_unicode_range(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnicodeRange {
+    #[doc = "Calls [FoldAstPath`::fold_unicode_range`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_unicode_range(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UnicodeRange {
                 span,
@@ -121064,70 +106375,147 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for UnicodeRange {
                 end,
                 raw,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(start, visitor)
+                let start = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::Start,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        start,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(end, visitor)
+                let end = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::End,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        end,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnicodeRange(
+                        self::fields::UnicodeRangeField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                UnicodeRange {
+                    span,
+                    start,
+                    end,
+                    raw,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UniversalSelector {
-    #[doc = "Calls [VisitAll`::visit_universal_selector`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_universal_selector(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UniversalSelector {
+    #[doc = "Calls [FoldAstPath`::fold_universal_selector`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_universal_selector(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UniversalSelector { span, prefix } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
+                        self::fields::UniversalSelectorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<NamespacePrefix> as VisitAllWith<V>>::visit_with(prefix, visitor)
+                let prefix = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UniversalSelector(
+                        self::fields::UniversalSelectorField::Prefix,
+                    ));
+                    <Option<NamespacePrefix> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                UniversalSelector { span, prefix }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UnknownDimension {
-    #[doc = "Calls [VisitAll`::visit_unknown_dimension`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_unknown_dimension(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnknownDimension {
+    #[doc = "Calls [FoldAstPath`::fold_unknown_dimension`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_unknown_dimension(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UnknownDimension { span, value, unit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
+                        self::fields::UnknownDimensionField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Number as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
+                        self::fields::UnknownDimensionField::Value,
+                    ));
+                    <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(unit, visitor)
+                let unit = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UnknownDimension(
+                        self::fields::UnknownDimensionField::Unit,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        unit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                UnknownDimension { span, value, unit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Url {
-    #[doc = "Calls [VisitAll`::visit_url`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_url(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Url {
+    #[doc = "Calls [FoldAstPath`::fold_url`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_url(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Url {
                 span,
@@ -121135,967 +106523,1415 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Url {
                 value,
                 modifiers,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Name));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<UrlValue>> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Url(self::fields::UrlField::Value));
+                    <Option<Box<UrlValue>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Vec<UrlModifier>> as VisitAllWith<V>>::visit_with(modifiers, visitor)
+                let modifiers = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Url(
+                        self::fields::UrlField::Modifiers(usize::MAX),
+                    ));
+                    <Option<Vec<UrlModifier>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        modifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Url {
+                    span,
+                    name,
+                    value,
+                    modifiers,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UrlKeyValue {
-    #[doc = "Calls [VisitAll`::visit_url_key_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_url_key_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlKeyValue {
+    #[doc = "Calls [FoldAstPath`::fold_url_key_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_url_key_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UrlKeyValue {
                 0: _field_0,
                 1: _field_1,
             } => {
-                <swc_atoms::Atom as VisitAllWith<V>>::visit_with(_field_0, visitor);
-                <swc_atoms::Atom as VisitAllWith<V>>::visit_with(_field_1, visitor);
+                let _field_0 = <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                let _field_1 = <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_1,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                UrlKeyValue {
+                    0: _field_0,
+                    1: _field_1,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UrlModifier {
-    #[doc = "Calls [VisitAll`::visit_url_modifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_url_modifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlModifier {
+    #[doc = "Calls [FoldAstPath`::fold_url_modifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_url_modifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UrlModifier::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
+                    self::fields::UrlModifierField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                UrlModifier::Ident { 0: _field_0 }
             }
             UrlModifier::Function { 0: _field_0 } => {
-                <Function as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlModifier(
+                    self::fields::UrlModifierField::Function,
+                ));
+                let _field_0 = <Function as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                UrlModifier::Function { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UrlValue {
-    #[doc = "Calls [VisitAll`::visit_url_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_url_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlValue {
+    #[doc = "Calls [FoldAstPath`::fold_url_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_url_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UrlValue::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Str));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                UrlValue::Str { 0: _field_0 }
             }
             UrlValue::Raw { 0: _field_0 } => {
-                <UrlValueRaw as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::UrlValue(self::fields::UrlValueField::Raw));
+                let _field_0 = <UrlValueRaw as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                UrlValue::Raw { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UrlValueRaw {
-    #[doc = "Calls [VisitAll`::visit_url_value_raw`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_url_value_raw(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UrlValueRaw {
+    #[doc = "Calls [FoldAstPath`::fold_url_value_raw`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_url_value_raw(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UrlValueRaw { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
+                        self::fields::UrlValueRawField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
+                        self::fields::UrlValueRawField::Value,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UrlValueRaw(
+                        self::fields::UrlValueRawField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                UrlValueRaw { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for WqName {
-    #[doc = "Calls [VisitAll`::visit_wq_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_wq_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WqName {
+    #[doc = "Calls [FoldAstPath`::fold_wq_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_wq_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             WqName {
                 span,
                 prefix,
                 value,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<NamespacePrefix> as VisitAllWith<V>>::visit_with(prefix, visitor)
+                let prefix = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Prefix));
+                    <Option<NamespacePrefix> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prefix,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WqName(self::fields::WqNameField::Value));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                WqName {
+                    span,
+                    prefix,
+                    value,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitAll`::visit_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
+    #[doc = "Calls [FoldAstPath`::fold_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_atom(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CalcProductOrOperator] {
-    #[doc = "Calls [VisitAll`::visit_calc_product_or_operators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CalcProductOrOperator> {
+    #[doc = "Calls [FoldAstPath`::fold_calc_product_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_product_or_operators(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_product_or_operators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CalcProductOrOperator as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <CalcProductOrOperator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CalcValueOrOperator] {
-    #[doc = "Calls [VisitAll`::visit_calc_value_or_operators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CalcValueOrOperator> {
+    #[doc = "Calls [FoldAstPath`::fold_calc_value_or_operators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_calc_value_or_operators(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_calc_value_or_operators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CalcValueOrOperator as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <CalcValueOrOperator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComplexSelectorChildren] {
-    #[doc = "Calls [VisitAll`::visit_complex_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComplexSelectorChildren> {
+    #[doc = "Calls [FoldAstPath`::fold_complex_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_complex_selector_childrens(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_complex_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <ComplexSelectorChildren as VisitAllWith<V>>::visit_with(item, visitor)
-        })
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ComplexSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComplexSelector] {
-    #[doc = "Calls [VisitAll`::visit_complex_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComplexSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_complex_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_complex_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ComplexSelector as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComponentValue] {
-    #[doc = "Calls [VisitAll`::visit_component_values`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComponentValue> {
+    #[doc = "Calls [FoldAstPath`::fold_component_values`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_component_values(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_component_values(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ComponentValue as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ComponentValue as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CompoundSelector] {
-    #[doc = "Calls [VisitAll`::visit_compound_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CompoundSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_compound_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_compound_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_compound_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CompoundSelector as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ContainerQueryType] {
-    #[doc = "Calls [VisitAll`::visit_container_query_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ContainerQueryType> {
+    #[doc = "Calls [FoldAstPath`::fold_container_query_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_container_query_types(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_container_query_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ContainerQueryType as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ContainerQueryType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CustomIdent] {
-    #[doc = "Calls [VisitAll`::visit_custom_idents`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CustomIdent> {
+    #[doc = "Calls [FoldAstPath`::fold_custom_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_custom_idents(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_custom_idents(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <CustomIdent as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <CustomIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [DocumentPreludeMatchingFunction] {
-    #[doc = "Calls [VisitAll`::visit_document_prelude_matching_functions`] with `self`. (Extra \
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<DocumentPreludeMatchingFunction> {
+    #[doc = "Calls [FoldAstPath`::fold_document_prelude_matching_functions`] with `self`. (Extra \
              impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_prelude_matching_functions(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <DocumentPreludeMatchingFunction as VisitAllWith<V>>::visit_with(item, visitor)
-        })
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [FamilyName] {
-    #[doc = "Calls [VisitAll`::visit_family_names`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_family_names(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_document_prelude_matching_functions(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <FamilyName as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <DocumentPreludeMatchingFunction as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ForgivingComplexSelector] {
-    #[doc = "Calls [VisitAll`::visit_forgiving_complex_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<FamilyName> {
+    #[doc = "Calls [FoldAstPath`::fold_family_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_forgiving_complex_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_family_names(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <ForgivingComplexSelector as VisitAllWith<V>>::visit_with(item, visitor)
-        })
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <FamilyName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ForgivingRelativeSelector] {
-    #[doc = "Calls [VisitAll`::visit_forgiving_relative_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ForgivingComplexSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_forgiving_complex_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_forgiving_relative_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_forgiving_complex_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <ForgivingRelativeSelector as VisitAllWith<V>>::visit_with(item, visitor)
-        })
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ForgivingComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Ident] {
-    #[doc = "Calls [VisitAll`::visit_idents`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ForgivingRelativeSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_forgiving_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_idents(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_forgiving_relative_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Ident as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ForgivingRelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [KeyframeSelector] {
-    #[doc = "Calls [VisitAll`::visit_keyframe_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Ident> {
+    #[doc = "Calls [FoldAstPath`::fold_idents`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_keyframe_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_idents(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <KeyframeSelector as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Ident as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [LayerName] {
-    #[doc = "Calls [VisitAll`::visit_layer_names`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<KeyframeSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_keyframe_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_layer_names(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_keyframe_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <LayerName as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <KeyframeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaConditionAllType] {
-    #[doc = "Calls [VisitAll`::visit_media_condition_all_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<LayerName> {
+    #[doc = "Calls [FoldAstPath`::fold_layer_names`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_condition_all_types(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_layer_names(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <MediaConditionAllType as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <LayerName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaConditionWithoutOrType] {
-    #[doc = "Calls [VisitAll`::visit_media_condition_without_or_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaConditionAllType> {
+    #[doc = "Calls [FoldAstPath`::fold_media_condition_all_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_condition_without_or_types(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_condition_all_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <MediaConditionWithoutOrType as VisitAllWith<V>>::visit_with(item, visitor)
-        })
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <MediaConditionAllType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaQuery] {
-    #[doc = "Calls [VisitAll`::visit_media_querys`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaConditionWithoutOrType> {
+    #[doc = "Calls [FoldAstPath`::fold_media_condition_without_or_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_media_querys(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_condition_without_or_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <MediaQuery as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <MediaConditionWithoutOrType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<AtRulePrelude>> {
-    #[doc = "Calls [VisitAll`::visit_opt_at_rule_prelude`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaQuery> {
+    #[doc = "Calls [FoldAstPath`::fold_media_querys`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_at_rule_prelude(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_media_querys(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<AtRulePrelude> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <MediaQuery as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitAll`::visit_opt_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<AtRulePrelude>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_at_rule_prelude`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_atom(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_at_rule_prelude(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_atoms::Atom as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<AtRulePrelude> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorMatcher> {
-    #[doc = "Calls [VisitAll`::visit_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_attribute_selector_matcher(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <AttributeSelectorMatcher as VisitAllWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorModifier> {
-    #[doc = "Calls [VisitAll`::visit_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorMatcher> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_attribute_selector_modifier(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_attribute_selector_matcher(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <AttributeSelectorModifier as VisitAllWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <AttributeSelectorMatcher as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorValue> {
-    #[doc = "Calls [VisitAll`::visit_opt_attribute_selector_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorModifier> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_attribute_selector_value(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_attribute_selector_modifier(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <AttributeSelectorValue as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <AttributeSelectorModifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Combinator> {
-    #[doc = "Calls [VisitAll`::visit_opt_combinator`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorValue> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_attribute_selector_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_combinator(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_attribute_selector_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Combinator as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <AttributeSelectorValue as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ContainerName> {
-    #[doc = "Calls [VisitAll`::visit_opt_container_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Combinator> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_combinator`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_container_name(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_combinator(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ContainerName as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Combinator as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ForgivingSelectorList> {
-    #[doc = "Calls [VisitAll`::visit_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ContainerName> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_container_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_forgiving_selector_list(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_container_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ForgivingSelectorList as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <ContainerName as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Function>> {
-    #[doc = "Calls [VisitAll`::visit_opt_function`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ForgivingSelectorList> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_function(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_forgiving_selector_list(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Function> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <ForgivingSelectorList as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Ident> {
-    #[doc = "Calls [VisitAll`::visit_opt_ident`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Function>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_function`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ident(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_function(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Ident as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ImportConditions>> {
-    #[doc = "Calls [VisitAll`::visit_opt_import_conditions`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Ident> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_import_conditions(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ident(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<ImportConditions> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Ident as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ImportLayerName>> {
-    #[doc = "Calls [VisitAll`::visit_opt_import_layer_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ImportConditions>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_import_conditions`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_import_layer_name(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_import_conditions(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<ImportLayerName> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<ImportConditions> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ImportantFlag> {
-    #[doc = "Calls [VisitAll`::visit_opt_important_flag`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ImportLayerName>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_import_layer_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_important_flag(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_import_layer_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ImportantFlag as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<ImportLayerName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<MediaConditionType>> {
-    #[doc = "Calls [VisitAll`::visit_opt_media_condition_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ImportantFlag> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_important_flag`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_media_condition_type(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_important_flag(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<MediaConditionType> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <ImportantFlag as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<MediaQueryList>> {
-    #[doc = "Calls [VisitAll`::visit_opt_media_query_list`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<MediaConditionType>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_media_condition_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_media_query_list(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_media_condition_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<MediaQueryList> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<MediaConditionType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<MediaType> {
-    #[doc = "Calls [VisitAll`::visit_opt_media_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<MediaQueryList>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_media_query_list`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_media_type(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_media_query_list(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <MediaType as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<MediaQueryList> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Namespace> {
-    #[doc = "Calls [VisitAll`::visit_opt_namespace`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<MediaType> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_media_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_namespace(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_media_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Namespace as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <MediaType as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<NamespacePrefix> {
-    #[doc = "Calls [VisitAll`::visit_opt_namespace_prefix`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Namespace> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_namespace`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_namespace_prefix(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_namespace(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <NamespacePrefix as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Namespace as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<NestingSelector> {
-    #[doc = "Calls [VisitAll`::visit_opt_nesting_selector`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<NamespacePrefix> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_namespace_prefix`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_nesting_selector(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_namespace_prefix(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <NestingSelector as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <NamespacePrefix as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Number> {
-    #[doc = "Calls [VisitAll`::visit_opt_number`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<NestingSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_nesting_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_number(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_nesting_selector(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Number as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <NestingSelector as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PageSelectorPseudo>> {
-    #[doc = "Calls [VisitAll`::visit_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Number> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_number`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_page_selector_pseudos(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_number(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Vec<PageSelectorPseudo> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Number as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<PageSelectorType> {
-    #[doc = "Calls [VisitAll`::visit_opt_page_selector_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PageSelectorPseudo>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_page_selector_type(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_page_selector_pseudos(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <PageSelectorType as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Vec<PageSelectorPseudo> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
-    #[doc = "Calls [VisitAll`::visit_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
-             impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<PageSelectorType> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_page_selector_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_pseudo_class_selector_childrens(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_page_selector_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <Vec<PseudoClassSelectorChildren> as VisitAllWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <PageSelectorType as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
-    #[doc = "Calls [VisitAll`::visit_opt_pseudo_element_selector_childrens`] with `self`. (Extra \
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PseudoClassSelectorChildren>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
              impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_pseudo_element_selector_childrens(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_pseudo_class_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <Vec<PseudoElementSelectorChildren> as VisitAllWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Vec<PseudoClassSelectorChildren> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<SimpleBlock> {
-    #[doc = "Calls [VisitAll`::visit_opt_simple_block`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PseudoElementSelectorChildren>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_pseudo_element_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_simple_block(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_pseudo_element_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <SimpleBlock as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Vec<PseudoElementSelectorChildren> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TypeSelector>> {
-    #[doc = "Calls [VisitAll`::visit_opt_type_selector`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<SimpleBlock> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_simple_block`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_type_selector(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_simple_block(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TypeSelector> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <SimpleBlock as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<UrlModifier>> {
-    #[doc = "Calls [VisitAll`::visit_opt_url_modifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TypeSelector>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_type_selector`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_url_modifiers(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_type_selector(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Vec<UrlModifier> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<TypeSelector> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<UrlValue>> {
-    #[doc = "Calls [VisitAll`::visit_opt_url_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<UrlModifier>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_url_value(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_url_modifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<UrlValue> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Vec<UrlModifier> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PageSelectorPseudo] {
-    #[doc = "Calls [VisitAll`::visit_page_selector_pseudos`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<UrlValue>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_url_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_page_selector_pseudos(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_url_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <PageSelectorPseudo as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<UrlValue> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PageSelector] {
-    #[doc = "Calls [VisitAll`::visit_page_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PageSelectorPseudo> {
+    #[doc = "Calls [FoldAstPath`::fold_page_selector_pseudos`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_page_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_page_selector_pseudos(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <PageSelector as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <PageSelectorPseudo as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PseudoClassSelectorChildren] {
-    #[doc = "Calls [VisitAll`::visit_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PageSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_page_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pseudo_class_selector_childrens(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_page_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <PseudoClassSelectorChildren as VisitAllWith<V>>::visit_with(item, visitor)
-        })
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <PageSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PseudoElementSelectorChildren] {
-    #[doc = "Calls [VisitAll`::visit_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PseudoClassSelectorChildren> {
+    #[doc = "Calls [FoldAstPath`::fold_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pseudo_element_selector_childrens(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pseudo_class_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter().for_each(|item| {
-            <PseudoElementSelectorChildren as VisitAllWith<V>>::visit_with(item, visitor)
-        })
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <PseudoClassSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [RelativeSelector] {
-    #[doc = "Calls [VisitAll`::visit_relative_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PseudoElementSelectorChildren> {
+    #[doc = "Calls [FoldAstPath`::fold_pseudo_element_selector_childrens`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_relative_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pseudo_element_selector_childrens(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <RelativeSelector as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <PseudoElementSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Rule] {
-    #[doc = "Calls [VisitAll`::visit_rules`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<RelativeSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_relative_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_rules(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_relative_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Rule as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <RelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_common::Span {
-    #[doc = "Calls [VisitAll`::visit_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Rule> {
+    #[doc = "Calls [FoldAstPath`::fold_rules`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_span(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_rules(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Rule as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SubclassSelector] {
-    #[doc = "Calls [VisitAll`::visit_subclass_selectors`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::Span {
+    #[doc = "Calls [FoldAstPath`::fold_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_subclass_selectors(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <SubclassSelector as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SupportsConditionType] {
-    #[doc = "Calls [VisitAll`::visit_supports_condition_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SubclassSelector> {
+    #[doc = "Calls [FoldAstPath`::fold_subclass_selectors`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_supports_condition_types(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_subclass_selectors(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <SupportsConditionType as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <SubclassSelector as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [UrlModifier] {
-    #[doc = "Calls [VisitAll`::visit_url_modifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SupportsConditionType> {
+    #[doc = "Calls [FoldAstPath`::fold_supports_condition_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_url_modifiers(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_supports_condition_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <UrlModifier as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <SupportsConditionType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V, T> VisitAllWith<V> for std::boxed::Box<T>
-where
-    V: ?Sized + VisitAll,
-    T: VisitAllWith<V>,
-{
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<UrlModifier> {
+    #[doc = "Calls [FoldAstPath`::fold_url_modifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_with(&**self, visitor);
-        v
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_url_modifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_children_with(&**self, visitor);
-        v
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <UrlModifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V, T> VisitAllWith<V> for std::vec::Vec<T>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> FoldWithAstPath<V> for std::boxed::Box<T>
 where
-    V: ?Sized + VisitAll,
-    [T]: VisitAllWith<V>,
+    V: ?Sized + FoldAstPath,
+    T: FoldWithAstPath<V>,
 {
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_with(self, visitor);
-        v
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        swc_visit::util::map::Map::map(self, |inner| {
+            <T as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_children_with(self, visitor);
-        v
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        swc_visit::util::map::Map::map(self, |inner| {
+            <T as FoldWithAstPath<V>>::fold_children_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
 #[cfg(any(docsrs, feature = "path"))]
diff --git a/crates/swc_ecma_parser/tests/visitor.rs b/crates/swc_ecma_parser/tests/visitor.rs
deleted file mode 100644
index 2b4a30a64cad..000000000000
--- a/crates/swc_ecma_parser/tests/visitor.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use swc_common::{input::StringInput, FileName};
-use swc_ecma_ast::*;
-use swc_ecma_parser::{lexer::Lexer, Parser};
-use swc_ecma_visit::{All, VisitAll, VisitWith};
-
-struct Issue1967;
-
-impl VisitAll for Issue1967 {
-    fn visit_expr(&mut self, _: &Expr) {
-        panic!("intended")
-    }
-}
-
-#[test]
-#[should_panic = "intended"]
-fn issue_1967() {
-    testing::run_test2(false, |cm, _handler| {
-        let fm = cm.new_source_file(
-            FileName::Anon.into(),
-            "function foo(){ return 'I'; }".to_string(),
-        );
-        let lexer = Lexer::new(
-            Default::default(),
-            EsVersion::latest(),
-            StringInput::from(&*fm),
-            None,
-        );
-
-        let mut parser = Parser::new_from(lexer);
-
-        let m = parser.parse_module().unwrap();
-
-        m.visit_with(&mut All {
-            visitor: Issue1967 {},
-        });
-
-        Ok(())
-    })
-    .unwrap();
-}
diff --git a/crates/swc_ecma_visit/src/generated.rs b/crates/swc_ecma_visit/src/generated.rs
index a2fb31abeff7..b8d1f79a4caf 100644
--- a/crates/swc_ecma_visit/src/generated.rs
+++ b/crates/swc_ecma_visit/src/generated.rs
@@ -9690,24917 +9690,20 @@ where
         }
     }
 }
-impl<V> Visit for ::swc_visit::All<V>
-where
-    V: VisitAll,
-{
-    #[inline]
-    fn visit_accessibility(&mut self, node: &Accessibility) {
-        <V as VisitAll>::visit_accessibility(&mut self.visitor, node);
-        <Accessibility as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_array_lit(&mut self, node: &ArrayLit) {
-        <V as VisitAll>::visit_array_lit(&mut self.visitor, node);
-        <ArrayLit as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_array_pat(&mut self, node: &ArrayPat) {
-        <V as VisitAll>::visit_array_pat(&mut self.visitor, node);
-        <ArrayPat as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
-        <V as VisitAll>::visit_arrow_expr(&mut self.visitor, node);
-        <ArrowExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_assign_expr(&mut self, node: &AssignExpr) {
-        <V as VisitAll>::visit_assign_expr(&mut self.visitor, node);
-        <AssignExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_assign_op(&mut self, node: &AssignOp) {
-        <V as VisitAll>::visit_assign_op(&mut self.visitor, node);
-        <AssignOp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_assign_pat(&mut self, node: &AssignPat) {
-        <V as VisitAll>::visit_assign_pat(&mut self.visitor, node);
-        <AssignPat as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
-        <V as VisitAll>::visit_assign_pat_prop(&mut self.visitor, node);
-        <AssignPatProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_assign_prop(&mut self, node: &AssignProp) {
-        <V as VisitAll>::visit_assign_prop(&mut self.visitor, node);
-        <AssignProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_assign_target(&mut self, node: &AssignTarget) {
-        <V as VisitAll>::visit_assign_target(&mut self.visitor, node);
-        <AssignTarget as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
-        <V as VisitAll>::visit_assign_target_pat(&mut self.visitor, node);
-        <AssignTargetPat as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut self.visitor, node);
-        <swc_atoms::Atom as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
-        <V as VisitAll>::visit_auto_accessor(&mut self.visitor, node);
-        <AutoAccessor as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_await_expr(&mut self, node: &AwaitExpr) {
-        <V as VisitAll>::visit_await_expr(&mut self.visitor, node);
-        <AwaitExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_big_int(&mut self, node: &BigInt) {
-        <V as VisitAll>::visit_big_int(&mut self.visitor, node);
-        <BigInt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_big_int_value(&mut self, node: &BigIntValue) {
-        <V as VisitAll>::visit_big_int_value(&mut self.visitor, node);
-        <BigIntValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_bin_expr(&mut self, node: &BinExpr) {
-        <V as VisitAll>::visit_bin_expr(&mut self.visitor, node);
-        <BinExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_binary_op(&mut self, node: &BinaryOp) {
-        <V as VisitAll>::visit_binary_op(&mut self.visitor, node);
-        <BinaryOp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_binding_ident(&mut self, node: &BindingIdent) {
-        <V as VisitAll>::visit_binding_ident(&mut self.visitor, node);
-        <BindingIdent as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_block_stmt(&mut self, node: &BlockStmt) {
-        <V as VisitAll>::visit_block_stmt(&mut self.visitor, node);
-        <BlockStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
-        <V as VisitAll>::visit_block_stmt_or_expr(&mut self.visitor, node);
-        <BlockStmtOrExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_bool(&mut self, node: &Bool) {
-        <V as VisitAll>::visit_bool(&mut self.visitor, node);
-        <Bool as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_break_stmt(&mut self, node: &BreakStmt) {
-        <V as VisitAll>::visit_break_stmt(&mut self.visitor, node);
-        <BreakStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_call_expr(&mut self, node: &CallExpr) {
-        <V as VisitAll>::visit_call_expr(&mut self.visitor, node);
-        <CallExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_callee(&mut self, node: &Callee) {
-        <V as VisitAll>::visit_callee(&mut self.visitor, node);
-        <Callee as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_catch_clause(&mut self, node: &CatchClause) {
-        <V as VisitAll>::visit_catch_clause(&mut self.visitor, node);
-        <CatchClause as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class(&mut self, node: &Class) {
-        <V as VisitAll>::visit_class(&mut self.visitor, node);
-        <Class as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class_decl(&mut self, node: &ClassDecl) {
-        <V as VisitAll>::visit_class_decl(&mut self.visitor, node);
-        <ClassDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class_expr(&mut self, node: &ClassExpr) {
-        <V as VisitAll>::visit_class_expr(&mut self.visitor, node);
-        <ClassExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class_member(&mut self, node: &ClassMember) {
-        <V as VisitAll>::visit_class_member(&mut self.visitor, node);
-        <ClassMember as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class_members(&mut self, node: &[ClassMember]) {
-        <V as VisitAll>::visit_class_members(&mut self.visitor, node);
-        <[ClassMember] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class_method(&mut self, node: &ClassMethod) {
-        <V as VisitAll>::visit_class_method(&mut self.visitor, node);
-        <ClassMethod as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_class_prop(&mut self, node: &ClassProp) {
-        <V as VisitAll>::visit_class_prop(&mut self.visitor, node);
-        <ClassProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
-        <V as VisitAll>::visit_computed_prop_name(&mut self.visitor, node);
-        <ComputedPropName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_cond_expr(&mut self, node: &CondExpr) {
-        <V as VisitAll>::visit_cond_expr(&mut self.visitor, node);
-        <CondExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_constructor(&mut self, node: &Constructor) {
-        <V as VisitAll>::visit_constructor(&mut self.visitor, node);
-        <Constructor as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
-        <V as VisitAll>::visit_continue_stmt(&mut self.visitor, node);
-        <ContinueStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
-        <V as VisitAll>::visit_debugger_stmt(&mut self.visitor, node);
-        <DebuggerStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_decl(&mut self, node: &Decl) {
-        <V as VisitAll>::visit_decl(&mut self.visitor, node);
-        <Decl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_decorator(&mut self, node: &Decorator) {
-        <V as VisitAll>::visit_decorator(&mut self.visitor, node);
-        <Decorator as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_decorators(&mut self, node: &[Decorator]) {
-        <V as VisitAll>::visit_decorators(&mut self.visitor, node);
-        <[Decorator] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_default_decl(&mut self, node: &DefaultDecl) {
-        <V as VisitAll>::visit_default_decl(&mut self.visitor, node);
-        <DefaultDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
-        <V as VisitAll>::visit_do_while_stmt(&mut self.visitor, node);
-        <DoWhileStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
-        <V as VisitAll>::visit_empty_stmt(&mut self.visitor, node);
-        <EmptyStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_es_version(&mut self, node: &EsVersion) {
-        <V as VisitAll>::visit_es_version(&mut self.visitor, node);
-        <EsVersion as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_all(&mut self, node: &ExportAll) {
-        <V as VisitAll>::visit_export_all(&mut self.visitor, node);
-        <ExportAll as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_decl(&mut self, node: &ExportDecl) {
-        <V as VisitAll>::visit_export_decl(&mut self.visitor, node);
-        <ExportDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
-        <V as VisitAll>::visit_export_default_decl(&mut self.visitor, node);
-        <ExportDefaultDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
-        <V as VisitAll>::visit_export_default_expr(&mut self.visitor, node);
-        <ExportDefaultExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
-        <V as VisitAll>::visit_export_default_specifier(&mut self.visitor, node);
-        <ExportDefaultSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
-        <V as VisitAll>::visit_export_named_specifier(&mut self.visitor, node);
-        <ExportNamedSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
-        <V as VisitAll>::visit_export_namespace_specifier(&mut self.visitor, node);
-        <ExportNamespaceSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
-        <V as VisitAll>::visit_export_specifier(&mut self.visitor, node);
-        <ExportSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
-        <V as VisitAll>::visit_export_specifiers(&mut self.visitor, node);
-        <[ExportSpecifier] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_expr(&mut self, node: &Expr) {
-        <V as VisitAll>::visit_expr(&mut self.visitor, node);
-        <Expr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
-        <V as VisitAll>::visit_expr_or_spread(&mut self.visitor, node);
-        <ExprOrSpread as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
-        <V as VisitAll>::visit_expr_or_spreads(&mut self.visitor, node);
-        <[ExprOrSpread] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_expr_stmt(&mut self, node: &ExprStmt) {
-        <V as VisitAll>::visit_expr_stmt(&mut self.visitor, node);
-        <ExprStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_exprs(&mut self, node: &[Box<Expr>]) {
-        <V as VisitAll>::visit_exprs(&mut self.visitor, node);
-        <[Box<Expr>] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_fn_decl(&mut self, node: &FnDecl) {
-        <V as VisitAll>::visit_fn_decl(&mut self.visitor, node);
-        <FnDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_fn_expr(&mut self, node: &FnExpr) {
-        <V as VisitAll>::visit_fn_expr(&mut self.visitor, node);
-        <FnExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_for_head(&mut self, node: &ForHead) {
-        <V as VisitAll>::visit_for_head(&mut self.visitor, node);
-        <ForHead as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
-        <V as VisitAll>::visit_for_in_stmt(&mut self.visitor, node);
-        <ForInStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
-        <V as VisitAll>::visit_for_of_stmt(&mut self.visitor, node);
-        <ForOfStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_for_stmt(&mut self, node: &ForStmt) {
-        <V as VisitAll>::visit_for_stmt(&mut self.visitor, node);
-        <ForStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <V as VisitAll>::visit_function(&mut self.visitor, node);
-        <Function as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_getter_prop(&mut self, node: &GetterProp) {
-        <V as VisitAll>::visit_getter_prop(&mut self.visitor, node);
-        <GetterProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <V as VisitAll>::visit_ident(&mut self.visitor, node);
-        <Ident as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ident_name(&mut self, node: &IdentName) {
-        <V as VisitAll>::visit_ident_name(&mut self.visitor, node);
-        <IdentName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_if_stmt(&mut self, node: &IfStmt) {
-        <V as VisitAll>::visit_if_stmt(&mut self.visitor, node);
-        <IfStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import(&mut self, node: &Import) {
-        <V as VisitAll>::visit_import(&mut self.visitor, node);
-        <Import as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_decl(&mut self, node: &ImportDecl) {
-        <V as VisitAll>::visit_import_decl(&mut self.visitor, node);
-        <ImportDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
-        <V as VisitAll>::visit_import_default_specifier(&mut self.visitor, node);
-        <ImportDefaultSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
-        <V as VisitAll>::visit_import_named_specifier(&mut self.visitor, node);
-        <ImportNamedSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_phase(&mut self, node: &ImportPhase) {
-        <V as VisitAll>::visit_import_phase(&mut self.visitor, node);
-        <ImportPhase as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
-        <V as VisitAll>::visit_import_specifier(&mut self.visitor, node);
-        <ImportSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
-        <V as VisitAll>::visit_import_specifiers(&mut self.visitor, node);
-        <[ImportSpecifier] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
-        <V as VisitAll>::visit_import_star_as_specifier(&mut self.visitor, node);
-        <ImportStarAsSpecifier as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_with(&mut self, node: &ImportWith) {
-        <V as VisitAll>::visit_import_with(&mut self.visitor, node);
-        <ImportWith as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_with_item(&mut self, node: &ImportWithItem) {
-        <V as VisitAll>::visit_import_with_item(&mut self.visitor, node);
-        <ImportWithItem as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
-        <V as VisitAll>::visit_import_with_items(&mut self.visitor, node);
-        <[ImportWithItem] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_invalid(&mut self, node: &Invalid) {
-        <V as VisitAll>::visit_invalid(&mut self.visitor, node);
-        <Invalid as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_attr(&mut self, node: &JSXAttr) {
-        <V as VisitAll>::visit_jsx_attr(&mut self.visitor, node);
-        <JSXAttr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
-        <V as VisitAll>::visit_jsx_attr_name(&mut self.visitor, node);
-        <JSXAttrName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
-        <V as VisitAll>::visit_jsx_attr_or_spread(&mut self.visitor, node);
-        <JSXAttrOrSpread as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
-        <V as VisitAll>::visit_jsx_attr_or_spreads(&mut self.visitor, node);
-        <[JSXAttrOrSpread] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
-        <V as VisitAll>::visit_jsx_attr_value(&mut self.visitor, node);
-        <JSXAttrValue as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
-        <V as VisitAll>::visit_jsx_closing_element(&mut self.visitor, node);
-        <JSXClosingElement as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
-        <V as VisitAll>::visit_jsx_closing_fragment(&mut self.visitor, node);
-        <JSXClosingFragment as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_element(&mut self, node: &JSXElement) {
-        <V as VisitAll>::visit_jsx_element(&mut self.visitor, node);
-        <JSXElement as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
-        <V as VisitAll>::visit_jsx_element_child(&mut self.visitor, node);
-        <JSXElementChild as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
-        <V as VisitAll>::visit_jsx_element_childs(&mut self.visitor, node);
-        <[JSXElementChild] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
-        <V as VisitAll>::visit_jsx_element_name(&mut self.visitor, node);
-        <JSXElementName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
-        <V as VisitAll>::visit_jsx_empty_expr(&mut self.visitor, node);
-        <JSXEmptyExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_expr(&mut self, node: &JSXExpr) {
-        <V as VisitAll>::visit_jsx_expr(&mut self.visitor, node);
-        <JSXExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
-        <V as VisitAll>::visit_jsx_expr_container(&mut self.visitor, node);
-        <JSXExprContainer as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
-        <V as VisitAll>::visit_jsx_fragment(&mut self.visitor, node);
-        <JSXFragment as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
-        <V as VisitAll>::visit_jsx_member_expr(&mut self.visitor, node);
-        <JSXMemberExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
-        <V as VisitAll>::visit_jsx_namespaced_name(&mut self.visitor, node);
-        <JSXNamespacedName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_object(&mut self, node: &JSXObject) {
-        <V as VisitAll>::visit_jsx_object(&mut self.visitor, node);
-        <JSXObject as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
-        <V as VisitAll>::visit_jsx_opening_element(&mut self.visitor, node);
-        <JSXOpeningElement as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
-        <V as VisitAll>::visit_jsx_opening_fragment(&mut self.visitor, node);
-        <JSXOpeningFragment as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
-        <V as VisitAll>::visit_jsx_spread_child(&mut self.visitor, node);
-        <JSXSpreadChild as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_jsx_text(&mut self, node: &JSXText) {
-        <V as VisitAll>::visit_jsx_text(&mut self.visitor, node);
-        <JSXText as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_key(&mut self, node: &Key) {
-        <V as VisitAll>::visit_key(&mut self.visitor, node);
-        <Key as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
-        <V as VisitAll>::visit_key_value_pat_prop(&mut self.visitor, node);
-        <KeyValuePatProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
-        <V as VisitAll>::visit_key_value_prop(&mut self.visitor, node);
-        <KeyValueProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
-        <V as VisitAll>::visit_labeled_stmt(&mut self.visitor, node);
-        <LabeledStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_lit(&mut self, node: &Lit) {
-        <V as VisitAll>::visit_lit(&mut self.visitor, node);
-        <Lit as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_member_expr(&mut self, node: &MemberExpr) {
-        <V as VisitAll>::visit_member_expr(&mut self.visitor, node);
-        <MemberExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_member_prop(&mut self, node: &MemberProp) {
-        <V as VisitAll>::visit_member_prop(&mut self.visitor, node);
-        <MemberProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
-        <V as VisitAll>::visit_meta_prop_expr(&mut self.visitor, node);
-        <MetaPropExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
-        <V as VisitAll>::visit_meta_prop_kind(&mut self.visitor, node);
-        <MetaPropKind as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_method_kind(&mut self, node: &MethodKind) {
-        <V as VisitAll>::visit_method_kind(&mut self.visitor, node);
-        <MethodKind as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_method_prop(&mut self, node: &MethodProp) {
-        <V as VisitAll>::visit_method_prop(&mut self.visitor, node);
-        <MethodProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_module(&mut self, node: &Module) {
-        <V as VisitAll>::visit_module(&mut self.visitor, node);
-        <Module as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_module_decl(&mut self, node: &ModuleDecl) {
-        <V as VisitAll>::visit_module_decl(&mut self.visitor, node);
-        <ModuleDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_module_export_name(&mut self, node: &ModuleExportName) {
-        <V as VisitAll>::visit_module_export_name(&mut self.visitor, node);
-        <ModuleExportName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_module_item(&mut self, node: &ModuleItem) {
-        <V as VisitAll>::visit_module_item(&mut self.visitor, node);
-        <ModuleItem as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_module_items(&mut self, node: &[ModuleItem]) {
-        <V as VisitAll>::visit_module_items(&mut self.visitor, node);
-        <[ModuleItem] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_named_export(&mut self, node: &NamedExport) {
-        <V as VisitAll>::visit_named_export(&mut self.visitor, node);
-        <NamedExport as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_new_expr(&mut self, node: &NewExpr) {
-        <V as VisitAll>::visit_new_expr(&mut self.visitor, node);
-        <NewExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_null(&mut self, node: &Null) {
-        <V as VisitAll>::visit_null(&mut self.visitor, node);
-        <Null as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <V as VisitAll>::visit_number(&mut self.visitor, node);
-        <Number as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_object_lit(&mut self, node: &ObjectLit) {
-        <V as VisitAll>::visit_object_lit(&mut self.visitor, node);
-        <ObjectLit as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_object_pat(&mut self, node: &ObjectPat) {
-        <V as VisitAll>::visit_object_pat(&mut self.visitor, node);
-        <ObjectPat as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
-        <V as VisitAll>::visit_object_pat_prop(&mut self.visitor, node);
-        <ObjectPatProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
-        <V as VisitAll>::visit_object_pat_props(&mut self.visitor, node);
-        <[ObjectPatProp] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
-        <V as VisitAll>::visit_opt_accessibility(&mut self.visitor, node);
-        <Option<Accessibility> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut self.visitor, node);
-        <Option<swc_atoms::Atom> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>) {
-        <V as VisitAll>::visit_opt_block_stmt(&mut self.visitor, node);
-        <Option<BlockStmt> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_call(&mut self, node: &OptCall) {
-        <V as VisitAll>::visit_opt_call(&mut self.visitor, node);
-        <OptCall as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>) {
-        <V as VisitAll>::visit_opt_catch_clause(&mut self.visitor, node);
-        <Option<CatchClause> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
-        <V as VisitAll>::visit_opt_chain_base(&mut self.visitor, node);
-        <OptChainBase as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
-        <V as VisitAll>::visit_opt_chain_expr(&mut self.visitor, node);
-        <OptChainExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>) {
-        <V as VisitAll>::visit_opt_expr(&mut self.visitor, node);
-        <Option<Box<Expr>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>) {
-        <V as VisitAll>::visit_opt_expr_or_spread(&mut self.visitor, node);
-        <Option<ExprOrSpread> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>) {
-        <V as VisitAll>::visit_opt_expr_or_spreads(&mut self.visitor, node);
-        <Option<Vec<ExprOrSpread>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <V as VisitAll>::visit_opt_ident(&mut self.visitor, node);
-        <Option<Ident> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>) {
-        <V as VisitAll>::visit_opt_jsx_attr_value(&mut self.visitor, node);
-        <Option<JSXAttrValue> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>) {
-        <V as VisitAll>::visit_opt_jsx_closing_element(&mut self.visitor, node);
-        <Option<JSXClosingElement> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_module_export_name(&mut self, node: &Option<ModuleExportName>) {
-        <V as VisitAll>::visit_opt_module_export_name(&mut self.visitor, node);
-        <Option<ModuleExportName> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_object_lit(&mut self, node: &Option<Box<ObjectLit>>) {
-        <V as VisitAll>::visit_opt_object_lit(&mut self.visitor, node);
-        <Option<Box<ObjectLit>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_pat(&mut self, node: &Option<Pat>) {
-        <V as VisitAll>::visit_opt_pat(&mut self.visitor, node);
-        <Option<Pat> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_span(&mut self, node: &Option<swc_common::Span>) {
-        <V as VisitAll>::visit_opt_span(&mut self.visitor, node);
-        <Option<swc_common::Span> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>) {
-        <V as VisitAll>::visit_opt_stmt(&mut self.visitor, node);
-        <Option<Box<Stmt>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_str(&mut self, node: &Option<Box<Str>>) {
-        <V as VisitAll>::visit_opt_str(&mut self.visitor, node);
-        <Option<Box<Str>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>) {
-        <V as VisitAll>::visit_opt_true_plus_minus(&mut self.visitor, node);
-        <Option<TruePlusMinus> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>) {
-        <V as VisitAll>::visit_opt_ts_entity_name(&mut self.visitor, node);
-        <Option<TsEntityName> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>) {
-        <V as VisitAll>::visit_opt_ts_namespace_body(&mut self.visitor, node);
-        <Option<TsNamespaceBody> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>) {
-        <V as VisitAll>::visit_opt_ts_type(&mut self.visitor, node);
-        <Option<Box<TsType>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>) {
-        <V as VisitAll>::visit_opt_ts_type_ann(&mut self.visitor, node);
-        <Option<Box<TsTypeAnn>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_decl(&mut self, node: &Option<Box<TsTypeParamDecl>>) {
-        <V as VisitAll>::visit_opt_ts_type_param_decl(&mut self.visitor, node);
-        <Option<Box<TsTypeParamDecl>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_instantiation(
-        &mut self,
-        node: &Option<Box<TsTypeParamInstantiation>>,
-    ) {
-        <V as VisitAll>::visit_opt_ts_type_param_instantiation(&mut self.visitor, node);
-        <Option<Box<TsTypeParamInstantiation>> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>) {
-        <V as VisitAll>::visit_opt_var_decl_or_expr(&mut self.visitor, node);
-        <Option<VarDeclOrExpr> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>]) {
-        <V as VisitAll>::visit_opt_vec_expr_or_spreads(&mut self.visitor, node);
-        <[Option<ExprOrSpread>] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>]) {
-        <V as VisitAll>::visit_opt_vec_pats(&mut self.visitor, node);
-        <[Option<Pat>] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_param(&mut self, node: &Param) {
-        <V as VisitAll>::visit_param(&mut self.visitor, node);
-        <Param as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp) {
-        <V as VisitAll>::visit_param_or_ts_param_prop(&mut self.visitor, node);
-        <ParamOrTsParamProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp]) {
-        <V as VisitAll>::visit_param_or_ts_param_props(&mut self.visitor, node);
-        <[ParamOrTsParamProp] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_params(&mut self, node: &[Param]) {
-        <V as VisitAll>::visit_params(&mut self.visitor, node);
-        <[Param] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_paren_expr(&mut self, node: &ParenExpr) {
-        <V as VisitAll>::visit_paren_expr(&mut self.visitor, node);
-        <ParenExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pat(&mut self, node: &Pat) {
-        <V as VisitAll>::visit_pat(&mut self.visitor, node);
-        <Pat as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_pats(&mut self, node: &[Pat]) {
-        <V as VisitAll>::visit_pats(&mut self.visitor, node);
-        <[Pat] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_private_method(&mut self, node: &PrivateMethod) {
-        <V as VisitAll>::visit_private_method(&mut self.visitor, node);
-        <PrivateMethod as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_private_name(&mut self, node: &PrivateName) {
-        <V as VisitAll>::visit_private_name(&mut self.visitor, node);
-        <PrivateName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_private_prop(&mut self, node: &PrivateProp) {
-        <V as VisitAll>::visit_private_prop(&mut self.visitor, node);
-        <PrivateProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_program(&mut self, node: &Program) {
-        <V as VisitAll>::visit_program(&mut self.visitor, node);
-        <Program as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_prop(&mut self, node: &Prop) {
-        <V as VisitAll>::visit_prop(&mut self.visitor, node);
-        <Prop as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_prop_name(&mut self, node: &PropName) {
-        <V as VisitAll>::visit_prop_name(&mut self.visitor, node);
-        <PropName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
-        <V as VisitAll>::visit_prop_or_spread(&mut self.visitor, node);
-        <PropOrSpread as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
-        <V as VisitAll>::visit_prop_or_spreads(&mut self.visitor, node);
-        <[PropOrSpread] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_regex(&mut self, node: &Regex) {
-        <V as VisitAll>::visit_regex(&mut self.visitor, node);
-        <Regex as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_rest_pat(&mut self, node: &RestPat) {
-        <V as VisitAll>::visit_rest_pat(&mut self.visitor, node);
-        <RestPat as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_return_stmt(&mut self, node: &ReturnStmt) {
-        <V as VisitAll>::visit_return_stmt(&mut self.visitor, node);
-        <ReturnStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_script(&mut self, node: &Script) {
-        <V as VisitAll>::visit_script(&mut self.visitor, node);
-        <Script as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_seq_expr(&mut self, node: &SeqExpr) {
-        <V as VisitAll>::visit_seq_expr(&mut self.visitor, node);
-        <SeqExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_setter_prop(&mut self, node: &SetterProp) {
-        <V as VisitAll>::visit_setter_prop(&mut self.visitor, node);
-        <SetterProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
-        <V as VisitAll>::visit_simple_assign_target(&mut self.visitor, node);
-        <SimpleAssignTarget as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut self.visitor, node);
-        <swc_common::Span as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_spread_element(&mut self, node: &SpreadElement) {
-        <V as VisitAll>::visit_spread_element(&mut self.visitor, node);
-        <SpreadElement as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_static_block(&mut self, node: &StaticBlock) {
-        <V as VisitAll>::visit_static_block(&mut self.visitor, node);
-        <StaticBlock as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_stmt(&mut self, node: &Stmt) {
-        <V as VisitAll>::visit_stmt(&mut self.visitor, node);
-        <Stmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_stmts(&mut self, node: &[Stmt]) {
-        <V as VisitAll>::visit_stmts(&mut self.visitor, node);
-        <[Stmt] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <V as VisitAll>::visit_str(&mut self.visitor, node);
-        <Str as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_super(&mut self, node: &Super) {
-        <V as VisitAll>::visit_super(&mut self.visitor, node);
-        <Super as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_super_prop(&mut self, node: &SuperProp) {
-        <V as VisitAll>::visit_super_prop(&mut self.visitor, node);
-        <SuperProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
-        <V as VisitAll>::visit_super_prop_expr(&mut self.visitor, node);
-        <SuperPropExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_switch_case(&mut self, node: &SwitchCase) {
-        <V as VisitAll>::visit_switch_case(&mut self.visitor, node);
-        <SwitchCase as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
-        <V as VisitAll>::visit_switch_cases(&mut self.visitor, node);
-        <[SwitchCase] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
-        <V as VisitAll>::visit_switch_stmt(&mut self.visitor, node);
-        <SwitchStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_syntax_context(&mut self, node: &swc_common::SyntaxContext) {
-        <V as VisitAll>::visit_syntax_context(&mut self.visitor, node);
-        <swc_common::SyntaxContext as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
-        <V as VisitAll>::visit_tagged_tpl(&mut self.visitor, node);
-        <TaggedTpl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_this_expr(&mut self, node: &ThisExpr) {
-        <V as VisitAll>::visit_this_expr(&mut self.visitor, node);
-        <ThisExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
-        <V as VisitAll>::visit_throw_stmt(&mut self.visitor, node);
-        <ThrowStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_tpl(&mut self, node: &Tpl) {
-        <V as VisitAll>::visit_tpl(&mut self.visitor, node);
-        <Tpl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_tpl_element(&mut self, node: &TplElement) {
-        <V as VisitAll>::visit_tpl_element(&mut self.visitor, node);
-        <TplElement as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_tpl_elements(&mut self, node: &[TplElement]) {
-        <V as VisitAll>::visit_tpl_elements(&mut self.visitor, node);
-        <[TplElement] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
-        <V as VisitAll>::visit_true_plus_minus(&mut self.visitor, node);
-        <TruePlusMinus as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_try_stmt(&mut self, node: &TryStmt) {
-        <V as VisitAll>::visit_try_stmt(&mut self.visitor, node);
-        <TryStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_array_type(&mut self, node: &TsArrayType) {
-        <V as VisitAll>::visit_ts_array_type(&mut self.visitor, node);
-        <TsArrayType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
-        <V as VisitAll>::visit_ts_as_expr(&mut self.visitor, node);
-        <TsAsExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
-        <V as VisitAll>::visit_ts_call_signature_decl(&mut self.visitor, node);
-        <TsCallSignatureDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
-        <V as VisitAll>::visit_ts_conditional_type(&mut self.visitor, node);
-        <TsConditionalType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
-        <V as VisitAll>::visit_ts_const_assertion(&mut self.visitor, node);
-        <TsConstAssertion as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
-        <V as VisitAll>::visit_ts_construct_signature_decl(&mut self.visitor, node);
-        <TsConstructSignatureDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
-        <V as VisitAll>::visit_ts_constructor_type(&mut self.visitor, node);
-        <TsConstructorType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
-        <V as VisitAll>::visit_ts_entity_name(&mut self.visitor, node);
-        <TsEntityName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
-        <V as VisitAll>::visit_ts_enum_decl(&mut self.visitor, node);
-        <TsEnumDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
-        <V as VisitAll>::visit_ts_enum_member(&mut self.visitor, node);
-        <TsEnumMember as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
-        <V as VisitAll>::visit_ts_enum_member_id(&mut self.visitor, node);
-        <TsEnumMemberId as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
-        <V as VisitAll>::visit_ts_enum_members(&mut self.visitor, node);
-        <[TsEnumMember] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
-        <V as VisitAll>::visit_ts_export_assignment(&mut self.visitor, node);
-        <TsExportAssignment as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs) {
-        <V as VisitAll>::visit_ts_expr_with_type_args(&mut self.visitor, node);
-        <TsExprWithTypeArgs as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs]) {
-        <V as VisitAll>::visit_ts_expr_with_type_argss(&mut self.visitor, node);
-        <[TsExprWithTypeArgs] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
-        <V as VisitAll>::visit_ts_external_module_ref(&mut self.visitor, node);
-        <TsExternalModuleRef as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType) {
-        <V as VisitAll>::visit_ts_fn_or_constructor_type(&mut self.visitor, node);
-        <TsFnOrConstructorType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
-        <V as VisitAll>::visit_ts_fn_param(&mut self.visitor, node);
-        <TsFnParam as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
-        <V as VisitAll>::visit_ts_fn_params(&mut self.visitor, node);
-        <[TsFnParam] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_fn_type(&mut self, node: &TsFnType) {
-        <V as VisitAll>::visit_ts_fn_type(&mut self.visitor, node);
-        <TsFnType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
-        <V as VisitAll>::visit_ts_getter_signature(&mut self.visitor, node);
-        <TsGetterSignature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
-        <V as VisitAll>::visit_ts_import_equals_decl(&mut self.visitor, node);
-        <TsImportEqualsDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_import_type(&mut self, node: &TsImportType) {
-        <V as VisitAll>::visit_ts_import_type(&mut self.visitor, node);
-        <TsImportType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
-        <V as VisitAll>::visit_ts_index_signature(&mut self.visitor, node);
-        <TsIndexSignature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
-        <V as VisitAll>::visit_ts_indexed_access_type(&mut self.visitor, node);
-        <TsIndexedAccessType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_infer_type(&mut self, node: &TsInferType) {
-        <V as VisitAll>::visit_ts_infer_type(&mut self.visitor, node);
-        <TsInferType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
-        <V as VisitAll>::visit_ts_instantiation(&mut self.visitor, node);
-        <TsInstantiation as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
-        <V as VisitAll>::visit_ts_interface_body(&mut self.visitor, node);
-        <TsInterfaceBody as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
-        <V as VisitAll>::visit_ts_interface_decl(&mut self.visitor, node);
-        <TsInterfaceDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
-        <V as VisitAll>::visit_ts_intersection_type(&mut self.visitor, node);
-        <TsIntersectionType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
-        <V as VisitAll>::visit_ts_keyword_type(&mut self.visitor, node);
-        <TsKeywordType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
-        <V as VisitAll>::visit_ts_keyword_type_kind(&mut self.visitor, node);
-        <TsKeywordTypeKind as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_lit(&mut self, node: &TsLit) {
-        <V as VisitAll>::visit_ts_lit(&mut self.visitor, node);
-        <TsLit as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_lit_type(&mut self, node: &TsLitType) {
-        <V as VisitAll>::visit_ts_lit_type(&mut self.visitor, node);
-        <TsLitType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
-        <V as VisitAll>::visit_ts_mapped_type(&mut self.visitor, node);
-        <TsMappedType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
-        <V as VisitAll>::visit_ts_method_signature(&mut self.visitor, node);
-        <TsMethodSignature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
-        <V as VisitAll>::visit_ts_module_block(&mut self.visitor, node);
-        <TsModuleBlock as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
-        <V as VisitAll>::visit_ts_module_decl(&mut self.visitor, node);
-        <TsModuleDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_module_name(&mut self, node: &TsModuleName) {
-        <V as VisitAll>::visit_ts_module_name(&mut self.visitor, node);
-        <TsModuleName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
-        <V as VisitAll>::visit_ts_module_ref(&mut self.visitor, node);
-        <TsModuleRef as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
-        <V as VisitAll>::visit_ts_namespace_body(&mut self.visitor, node);
-        <TsNamespaceBody as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
-        <V as VisitAll>::visit_ts_namespace_decl(&mut self.visitor, node);
-        <TsNamespaceDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
-        <V as VisitAll>::visit_ts_namespace_export_decl(&mut self.visitor, node);
-        <TsNamespaceExportDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
-        <V as VisitAll>::visit_ts_non_null_expr(&mut self.visitor, node);
-        <TsNonNullExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
-        <V as VisitAll>::visit_ts_optional_type(&mut self.visitor, node);
-        <TsOptionalType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
-        <V as VisitAll>::visit_ts_param_prop(&mut self.visitor, node);
-        <TsParamProp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
-        <V as VisitAll>::visit_ts_param_prop_param(&mut self.visitor, node);
-        <TsParamPropParam as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
-        <V as VisitAll>::visit_ts_parenthesized_type(&mut self.visitor, node);
-        <TsParenthesizedType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
-        <V as VisitAll>::visit_ts_property_signature(&mut self.visitor, node);
-        <TsPropertySignature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
-        <V as VisitAll>::visit_ts_qualified_name(&mut self.visitor, node);
-        <TsQualifiedName as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_rest_type(&mut self, node: &TsRestType) {
-        <V as VisitAll>::visit_ts_rest_type(&mut self.visitor, node);
-        <TsRestType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
-        <V as VisitAll>::visit_ts_satisfies_expr(&mut self.visitor, node);
-        <TsSatisfiesExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
-        <V as VisitAll>::visit_ts_setter_signature(&mut self.visitor, node);
-        <TsSetterSignature as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_this_type(&mut self, node: &TsThisType) {
-        <V as VisitAll>::visit_ts_this_type(&mut self.visitor, node);
-        <TsThisType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent) {
-        <V as VisitAll>::visit_ts_this_type_or_ident(&mut self.visitor, node);
-        <TsThisTypeOrIdent as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
-        <V as VisitAll>::visit_ts_tpl_lit_type(&mut self.visitor, node);
-        <TsTplLitType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
-        <V as VisitAll>::visit_ts_tuple_element(&mut self.visitor, node);
-        <TsTupleElement as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
-        <V as VisitAll>::visit_ts_tuple_elements(&mut self.visitor, node);
-        <[TsTupleElement] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
-        <V as VisitAll>::visit_ts_tuple_type(&mut self.visitor, node);
-        <TsTupleType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type(&mut self, node: &TsType) {
-        <V as VisitAll>::visit_ts_type(&mut self.visitor, node);
-        <TsType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
-        <V as VisitAll>::visit_ts_type_alias_decl(&mut self.visitor, node);
-        <TsTypeAliasDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
-        <V as VisitAll>::visit_ts_type_ann(&mut self.visitor, node);
-        <TsTypeAnn as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
-        <V as VisitAll>::visit_ts_type_assertion(&mut self.visitor, node);
-        <TsTypeAssertion as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
-        <V as VisitAll>::visit_ts_type_element(&mut self.visitor, node);
-        <TsTypeElement as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
-        <V as VisitAll>::visit_ts_type_elements(&mut self.visitor, node);
-        <[TsTypeElement] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
-        <V as VisitAll>::visit_ts_type_lit(&mut self.visitor, node);
-        <TsTypeLit as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
-        <V as VisitAll>::visit_ts_type_operator(&mut self.visitor, node);
-        <TsTypeOperator as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
-        <V as VisitAll>::visit_ts_type_operator_op(&mut self.visitor, node);
-        <TsTypeOperatorOp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
-        <V as VisitAll>::visit_ts_type_param(&mut self.visitor, node);
-        <TsTypeParam as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
-        <V as VisitAll>::visit_ts_type_param_decl(&mut self.visitor, node);
-        <TsTypeParamDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
-        <V as VisitAll>::visit_ts_type_param_instantiation(&mut self.visitor, node);
-        <TsTypeParamInstantiation as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
-        <V as VisitAll>::visit_ts_type_params(&mut self.visitor, node);
-        <[TsTypeParam] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
-        <V as VisitAll>::visit_ts_type_predicate(&mut self.visitor, node);
-        <TsTypePredicate as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
-        <V as VisitAll>::visit_ts_type_query(&mut self.visitor, node);
-        <TsTypeQuery as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
-        <V as VisitAll>::visit_ts_type_query_expr(&mut self.visitor, node);
-        <TsTypeQueryExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
-        <V as VisitAll>::visit_ts_type_ref(&mut self.visitor, node);
-        <TsTypeRef as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
-        <V as VisitAll>::visit_ts_types(&mut self.visitor, node);
-        <[Box<TsType>] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_union_or_intersection_type(&mut self, node: &TsUnionOrIntersectionType) {
-        <V as VisitAll>::visit_ts_union_or_intersection_type(&mut self.visitor, node);
-        <TsUnionOrIntersectionType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_ts_union_type(&mut self, node: &TsUnionType) {
-        <V as VisitAll>::visit_ts_union_type(&mut self.visitor, node);
-        <TsUnionType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_unary_expr(&mut self, node: &UnaryExpr) {
-        <V as VisitAll>::visit_unary_expr(&mut self.visitor, node);
-        <UnaryExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_unary_op(&mut self, node: &UnaryOp) {
-        <V as VisitAll>::visit_unary_op(&mut self.visitor, node);
-        <UnaryOp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_update_expr(&mut self, node: &UpdateExpr) {
-        <V as VisitAll>::visit_update_expr(&mut self.visitor, node);
-        <UpdateExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_update_op(&mut self, node: &UpdateOp) {
-        <V as VisitAll>::visit_update_op(&mut self.visitor, node);
-        <UpdateOp as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_using_decl(&mut self, node: &UsingDecl) {
-        <V as VisitAll>::visit_using_decl(&mut self.visitor, node);
-        <UsingDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_var_decl(&mut self, node: &VarDecl) {
-        <V as VisitAll>::visit_var_decl(&mut self.visitor, node);
-        <VarDecl as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
-        <V as VisitAll>::visit_var_decl_kind(&mut self.visitor, node);
-        <VarDeclKind as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
-        <V as VisitAll>::visit_var_decl_or_expr(&mut self.visitor, node);
-        <VarDeclOrExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_var_declarator(&mut self, node: &VarDeclarator) {
-        <V as VisitAll>::visit_var_declarator(&mut self.visitor, node);
-        <VarDeclarator as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
-        <V as VisitAll>::visit_var_declarators(&mut self.visitor, node);
-        <[VarDeclarator] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_while_stmt(&mut self, node: &WhileStmt) {
-        <V as VisitAll>::visit_while_stmt(&mut self.visitor, node);
-        <WhileStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_with_stmt(&mut self, node: &WithStmt) {
-        <V as VisitAll>::visit_with_stmt(&mut self.visitor, node);
-        <WithStmt as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_yield_expr(&mut self, node: &YieldExpr) {
-        <V as VisitAll>::visit_yield_expr(&mut self.visitor, node);
-        <YieldExpr as VisitWith<Self>>::visit_children_with(node, self);
-    }
-}
-#[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitWith<V: ?Sized + Visit> {
-    #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with(&self, visitor: &mut V);
-    #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with(&self, visitor: &mut V);
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Accessibility {
-    #[doc = "Calls [Visit`::visit_accessibility`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_accessibility(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Accessibility::Public => {}
-            Accessibility::Protected => {}
-            Accessibility::Private => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ArrayLit {
-    #[doc = "Calls [Visit`::visit_array_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_array_lit(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ArrayLit { span, elems } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Option<ExprOrSpread>> as VisitWith<V>>::visit_with(elems, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ArrayPat {
-    #[doc = "Calls [Visit`::visit_array_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_array_pat(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ArrayPat {
-                span,
-                elems,
-                optional,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Option<Pat>> as VisitWith<V>>::visit_with(elems, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ArrowExpr {
-    #[doc = "Calls [Visit`::visit_arrow_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_arrow_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ArrowExpr {
-                span,
-                ctxt,
-                params,
-                body,
-                is_async,
-                is_generator,
-                type_params,
-                return_type,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Vec<Pat> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Box<BlockStmtOrExpr> as VisitWith<V>>::visit_with(body, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(return_type, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AssignExpr {
-    #[doc = "Calls [Visit`::visit_assign_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_assign_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AssignExpr {
-                span,
-                op,
-                left,
-                right,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <AssignOp as VisitWith<V>>::visit_with(op, visitor)
-                };
-                {
-                    <AssignTarget as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AssignOp {
-    #[doc = "Calls [Visit`::visit_assign_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_assign_op(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AssignOp::Assign => {}
-            AssignOp::AddAssign => {}
-            AssignOp::SubAssign => {}
-            AssignOp::MulAssign => {}
-            AssignOp::DivAssign => {}
-            AssignOp::ModAssign => {}
-            AssignOp::LShiftAssign => {}
-            AssignOp::RShiftAssign => {}
-            AssignOp::ZeroFillRShiftAssign => {}
-            AssignOp::BitOrAssign => {}
-            AssignOp::BitXorAssign => {}
-            AssignOp::BitAndAssign => {}
-            AssignOp::ExpAssign => {}
-            AssignOp::AndAssign => {}
-            AssignOp::OrAssign => {}
-            AssignOp::NullishAssign => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AssignPat {
-    #[doc = "Calls [Visit`::visit_assign_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_assign_pat(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AssignPat { span, left, right } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Pat> as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AssignPatProp {
-    #[doc = "Calls [Visit`::visit_assign_pat_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_assign_pat_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AssignPatProp { span, key, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <BindingIdent as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AssignProp {
-    #[doc = "Calls [Visit`::visit_assign_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_assign_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AssignProp { span, key, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AssignTarget {
-    #[doc = "Calls [Visit`::visit_assign_target`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_assign_target(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AssignTarget::Simple { 0: _field_0 } => {
-                <SimpleAssignTarget as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AssignTarget::Pat { 0: _field_0 } => {
-                <AssignTargetPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AssignTargetPat {
-    #[doc = "Calls [Visit`::visit_assign_target_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_assign_target_pat(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AssignTargetPat::Array { 0: _field_0 } => {
-                <ArrayPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AssignTargetPat::Object { 0: _field_0 } => {
-                <ObjectPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            AssignTargetPat::Invalid { 0: _field_0 } => {
-                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AutoAccessor {
-    #[doc = "Calls [Visit`::visit_auto_accessor`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_auto_accessor(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AutoAccessor {
-                span,
-                key,
-                value,
-                type_ann,
-                is_static,
-                decorators,
-                accessibility,
-                is_abstract,
-                is_override,
-                definite,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Key as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
-                };
-                {
-                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for AwaitExpr {
-    #[doc = "Calls [Visit`::visit_await_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_await_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AwaitExpr { span, arg } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BigInt {
-    #[doc = "Calls [Visit`::visit_big_int`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_big_int(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BigInt { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<BigIntValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BinExpr {
-    #[doc = "Calls [Visit`::visit_bin_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_bin_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BinExpr {
-                span,
-                op,
-                left,
-                right,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <BinaryOp as VisitWith<V>>::visit_with(op, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BinaryOp {
-    #[doc = "Calls [Visit`::visit_binary_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_binary_op(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BinaryOp::EqEq => {}
-            BinaryOp::NotEq => {}
-            BinaryOp::EqEqEq => {}
-            BinaryOp::NotEqEq => {}
-            BinaryOp::Lt => {}
-            BinaryOp::LtEq => {}
-            BinaryOp::Gt => {}
-            BinaryOp::GtEq => {}
-            BinaryOp::LShift => {}
-            BinaryOp::RShift => {}
-            BinaryOp::ZeroFillRShift => {}
-            BinaryOp::Add => {}
-            BinaryOp::Sub => {}
-            BinaryOp::Mul => {}
-            BinaryOp::Div => {}
-            BinaryOp::Mod => {}
-            BinaryOp::BitOr => {}
-            BinaryOp::BitXor => {}
-            BinaryOp::BitAnd => {}
-            BinaryOp::LogicalOr => {}
-            BinaryOp::LogicalAnd => {}
-            BinaryOp::In => {}
-            BinaryOp::InstanceOf => {}
-            BinaryOp::Exp => {}
-            BinaryOp::NullishCoalescing => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BindingIdent {
-    #[doc = "Calls [Visit`::visit_binding_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_binding_ident(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BindingIdent { id, type_ann } => {
-                {
-                    <Ident as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BlockStmt {
-    #[doc = "Calls [Visit`::visit_block_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_block_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BlockStmt { span, ctxt, stmts } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Vec<Stmt> as VisitWith<V>>::visit_with(stmts, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BlockStmtOrExpr {
-    #[doc = "Calls [Visit`::visit_block_stmt_or_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_block_stmt_or_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BlockStmtOrExpr::BlockStmt { 0: _field_0 } => {
-                <BlockStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            BlockStmtOrExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Bool {
-    #[doc = "Calls [Visit`::visit_bool`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_bool(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Bool { span, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BreakStmt {
-    #[doc = "Calls [Visit`::visit_break_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_break_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            BreakStmt { span, label } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(label, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CallExpr {
-    #[doc = "Calls [Visit`::visit_call_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_call_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CallExpr {
-                span,
-                ctxt,
-                callee,
-                args,
-                type_args,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Callee as VisitWith<V>>::visit_with(callee, visitor)
-                };
-                {
-                    <Vec<ExprOrSpread> as VisitWith<V>>::visit_with(args, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_args, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Callee {
-    #[doc = "Calls [Visit`::visit_callee`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_callee(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Callee::Super { 0: _field_0 } => {
-                <Super as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Callee::Import { 0: _field_0 } => {
-                <Import as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Callee::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CatchClause {
-    #[doc = "Calls [Visit`::visit_catch_clause`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_catch_clause(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CatchClause { span, param, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Pat> as VisitWith<V>>::visit_with(param, visitor)
-                };
-                {
-                    <BlockStmt as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Class {
-    #[doc = "Calls [Visit`::visit_class`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Class {
-                span,
-                ctxt,
-                decorators,
-                body,
-                super_class,
-                is_abstract,
-                type_params,
-                super_type_params,
-                implements,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
-                };
-                {
-                    <Vec<ClassMember> as VisitWith<V>>::visit_with(body, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(super_class, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        super_type_params,
-                        visitor,
-                    )
-                };
-                {
-                    <Vec<TsExprWithTypeArgs> as VisitWith<V>>::visit_with(implements, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ClassDecl {
-    #[doc = "Calls [Visit`::visit_class_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ClassDecl {
-                ident,
-                declare,
-                class,
-            } => {
-                {
-                    <Ident as VisitWith<V>>::visit_with(ident, visitor)
-                };
-                {
-                    <Box<Class> as VisitWith<V>>::visit_with(class, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ClassExpr {
-    #[doc = "Calls [Visit`::visit_class_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ClassExpr { ident, class } => {
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(ident, visitor)
-                };
-                {
-                    <Box<Class> as VisitWith<V>>::visit_with(class, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ClassMember {
-    #[doc = "Calls [Visit`::visit_class_member`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class_member(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ClassMember::Constructor { 0: _field_0 } => {
-                <Constructor as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::Method { 0: _field_0 } => {
-                <ClassMethod as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::PrivateMethod { 0: _field_0 } => {
-                <PrivateMethod as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::ClassProp { 0: _field_0 } => {
-                <ClassProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::PrivateProp { 0: _field_0 } => {
-                <PrivateProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::TsIndexSignature { 0: _field_0 } => {
-                <TsIndexSignature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::Empty { 0: _field_0 } => {
-                <EmptyStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::StaticBlock { 0: _field_0 } => {
-                <StaticBlock as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ClassMember::AutoAccessor { 0: _field_0 } => {
-                <AutoAccessor as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ClassMethod {
-    #[doc = "Calls [Visit`::visit_class_method`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class_method(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ClassMethod {
-                span,
-                key,
-                function,
-                kind,
-                is_static,
-                accessibility,
-                is_abstract,
-                is_optional,
-                is_override,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
-                };
-                {
-                    <MethodKind as VisitWith<V>>::visit_with(kind, visitor)
-                };
-                {
-                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ClassProp {
-    #[doc = "Calls [Visit`::visit_class_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ClassProp {
-                span,
-                key,
-                value,
-                type_ann,
-                is_static,
-                decorators,
-                accessibility,
-                is_abstract,
-                is_optional,
-                is_override,
-                readonly,
-                declare,
-                definite,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
-                };
-                {
-                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ComputedPropName {
-    #[doc = "Calls [Visit`::visit_computed_prop_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_computed_prop_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ComputedPropName { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for CondExpr {
-    #[doc = "Calls [Visit`::visit_cond_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_cond_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CondExpr {
-                span,
-                test,
-                cons,
-                alt,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(cons, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(alt, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Constructor {
-    #[doc = "Calls [Visit`::visit_constructor`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_constructor(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Constructor {
-                span,
-                ctxt,
-                key,
-                params,
-                body,
-                accessibility,
-                is_optional,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Vec<ParamOrTsParamProp> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-                {
-                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ContinueStmt {
-    #[doc = "Calls [Visit`::visit_continue_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_continue_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ContinueStmt { span, label } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(label, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DebuggerStmt {
-    #[doc = "Calls [Visit`::visit_debugger_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_debugger_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DebuggerStmt { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Decl {
-    #[doc = "Calls [Visit`::visit_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Decl::Class { 0: _field_0 } => {
-                <ClassDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Decl::Fn { 0: _field_0 } => {
-                <FnDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Decl::Var { 0: _field_0 } => {
-                <Box<VarDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Decl::Using { 0: _field_0 } => {
-                <Box<UsingDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Decl::TsInterface { 0: _field_0 } => {
-                <Box<TsInterfaceDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Decl::TsTypeAlias { 0: _field_0 } => {
-                <Box<TsTypeAliasDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Decl::TsEnum { 0: _field_0 } => {
-                <Box<TsEnumDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Decl::TsModule { 0: _field_0 } => {
-                <Box<TsModuleDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Decorator {
-    #[doc = "Calls [Visit`::visit_decorator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_decorator(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Decorator { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DefaultDecl {
-    #[doc = "Calls [Visit`::visit_default_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_default_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DefaultDecl::Class { 0: _field_0 } => {
-                <ClassExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            DefaultDecl::Fn { 0: _field_0 } => {
-                <FnExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            DefaultDecl::TsInterfaceDecl { 0: _field_0 } => {
-                <Box<TsInterfaceDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for DoWhileStmt {
-    #[doc = "Calls [Visit`::visit_do_while_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_do_while_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DoWhileStmt { span, test, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for EmptyStmt {
-    #[doc = "Calls [Visit`::visit_empty_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_empty_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            EmptyStmt { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for EsVersion {
-    #[doc = "Calls [Visit`::visit_es_version`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_es_version(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            EsVersion::Es3 => {}
-            EsVersion::Es5 => {}
-            EsVersion::Es2015 => {}
-            EsVersion::Es2016 => {}
-            EsVersion::Es2017 => {}
-            EsVersion::Es2018 => {}
-            EsVersion::Es2019 => {}
-            EsVersion::Es2020 => {}
-            EsVersion::Es2021 => {}
-            EsVersion::Es2022 => {}
-            EsVersion::EsNext => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportAll {
-    #[doc = "Calls [Visit`::visit_export_all`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_all(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportAll {
-                span,
-                src,
-                type_only,
-                with,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Str> as VisitWith<V>>::visit_with(src, visitor)
-                };
-                {
-                    <Option<Box<ObjectLit>> as VisitWith<V>>::visit_with(with, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportDecl {
-    #[doc = "Calls [Visit`::visit_export_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportDecl { span, decl } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Decl as VisitWith<V>>::visit_with(decl, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportDefaultDecl {
-    #[doc = "Calls [Visit`::visit_export_default_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_default_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportDefaultDecl { span, decl } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <DefaultDecl as VisitWith<V>>::visit_with(decl, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportDefaultExpr {
-    #[doc = "Calls [Visit`::visit_export_default_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_default_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportDefaultExpr { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportDefaultSpecifier {
-    #[doc = "Calls [Visit`::visit_export_default_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_default_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportDefaultSpecifier { exported } => {
-                {
-                    <Ident as VisitWith<V>>::visit_with(exported, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportNamedSpecifier {
-    #[doc = "Calls [Visit`::visit_export_named_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_named_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportNamedSpecifier {
-                span,
-                orig,
-                exported,
-                is_type_only,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <ModuleExportName as VisitWith<V>>::visit_with(orig, visitor)
-                };
-                {
-                    <Option<ModuleExportName> as VisitWith<V>>::visit_with(exported, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportNamespaceSpecifier {
-    #[doc = "Calls [Visit`::visit_export_namespace_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_namespace_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportNamespaceSpecifier { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <ModuleExportName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExportSpecifier {
-    #[doc = "Calls [Visit`::visit_export_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExportSpecifier::Namespace { 0: _field_0 } => {
-                <ExportNamespaceSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ExportSpecifier::Default { 0: _field_0 } => {
-                <ExportDefaultSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ExportSpecifier::Named { 0: _field_0 } => {
-                <ExportNamedSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Expr {
-    #[doc = "Calls [Visit`::visit_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Expr::This { 0: _field_0 } => {
-                <ThisExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Array { 0: _field_0 } => {
-                <ArrayLit as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Object { 0: _field_0 } => {
-                <ObjectLit as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Fn { 0: _field_0 } => {
-                <FnExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Unary { 0: _field_0 } => {
-                <UnaryExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Update { 0: _field_0 } => {
-                <UpdateExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Bin { 0: _field_0 } => {
-                <BinExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Assign { 0: _field_0 } => {
-                <AssignExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Member { 0: _field_0 } => {
-                <MemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::SuperProp { 0: _field_0 } => {
-                <SuperPropExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Cond { 0: _field_0 } => {
-                <CondExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Call { 0: _field_0 } => {
-                <CallExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::New { 0: _field_0 } => {
-                <NewExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Seq { 0: _field_0 } => {
-                <SeqExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Lit { 0: _field_0 } => {
-                <Lit as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Tpl { 0: _field_0 } => {
-                <Tpl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::TaggedTpl { 0: _field_0 } => {
-                <TaggedTpl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Arrow { 0: _field_0 } => {
-                <ArrowExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Class { 0: _field_0 } => {
-                <ClassExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Yield { 0: _field_0 } => {
-                <YieldExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::MetaProp { 0: _field_0 } => {
-                <MetaPropExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Await { 0: _field_0 } => {
-                <AwaitExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Paren { 0: _field_0 } => {
-                <ParenExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::JSXMember { 0: _field_0 } => {
-                <JSXMemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::JSXEmpty { 0: _field_0 } => {
-                <JSXEmptyExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::TsTypeAssertion { 0: _field_0 } => {
-                <TsTypeAssertion as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::TsConstAssertion { 0: _field_0 } => {
-                <TsConstAssertion as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::TsNonNull { 0: _field_0 } => {
-                <TsNonNullExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::TsAs { 0: _field_0 } => {
-                <TsAsExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::TsInstantiation { 0: _field_0 } => {
-                <TsInstantiation as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::TsSatisfies { 0: _field_0 } => {
-                <TsSatisfiesExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::PrivateName { 0: _field_0 } => {
-                <PrivateName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::OptChain { 0: _field_0 } => {
-                <OptChainExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Expr::Invalid { 0: _field_0 } => {
-                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExprOrSpread {
-    #[doc = "Calls [Visit`::visit_expr_or_spread`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_expr_or_spread(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExprOrSpread { spread, expr } => {
-                {
-                    <Option<swc_common::Span> as VisitWith<V>>::visit_with(spread, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ExprStmt {
-    #[doc = "Calls [Visit`::visit_expr_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_expr_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ExprStmt { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for FnDecl {
-    #[doc = "Calls [Visit`::visit_fn_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_fn_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            FnDecl {
-                ident,
-                declare,
-                function,
-            } => {
-                {
-                    <Ident as VisitWith<V>>::visit_with(ident, visitor)
-                };
-                {
-                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for FnExpr {
-    #[doc = "Calls [Visit`::visit_fn_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_fn_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            FnExpr { ident, function } => {
-                {
-                    <Option<Ident> as VisitWith<V>>::visit_with(ident, visitor)
-                };
-                {
-                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForHead {
-    #[doc = "Calls [Visit`::visit_for_head`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_for_head(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForHead::VarDecl { 0: _field_0 } => {
-                <Box<VarDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ForHead::UsingDecl { 0: _field_0 } => {
-                <Box<UsingDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ForHead::Pat { 0: _field_0 } => {
-                <Box<Pat> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForInStmt {
-    #[doc = "Calls [Visit`::visit_for_in_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_for_in_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForInStmt {
-                span,
-                left,
-                right,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <ForHead as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForOfStmt {
-    #[doc = "Calls [Visit`::visit_for_of_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_for_of_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForOfStmt {
-                span,
-                is_await,
-                left,
-                right,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <ForHead as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ForStmt {
-    #[doc = "Calls [Visit`::visit_for_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_for_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ForStmt {
-                span,
-                init,
-                test,
-                update,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<VarDeclOrExpr> as VisitWith<V>>::visit_with(init, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(test, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(update, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Function {
-    #[doc = "Calls [Visit`::visit_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_function(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Function {
-                params,
-                decorators,
-                span,
-                ctxt,
-                body,
-                is_generator,
-                is_async,
-                type_params,
-                return_type,
-            } => {
-                {
-                    <Vec<Param> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
-                };
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(return_type, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for GetterProp {
-    #[doc = "Calls [Visit`::visit_getter_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_getter_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            GetterProp {
-                span,
-                key,
-                type_ann,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Ident {
-    #[doc = "Calls [Visit`::visit_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ident(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Ident {
-                span,
-                ctxt,
-                sym,
-                optional,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(sym, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for IdentName {
-    #[doc = "Calls [Visit`::visit_ident_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ident_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            IdentName { span, sym } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(sym, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for IfStmt {
-    #[doc = "Calls [Visit`::visit_if_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_if_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            IfStmt {
-                span,
-                test,
-                cons,
-                alt,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(cons, visitor)
-                };
-                {
-                    <Option<Box<Stmt>> as VisitWith<V>>::visit_with(alt, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Import {
-    #[doc = "Calls [Visit`::visit_import`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Import { span, phase } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <ImportPhase as VisitWith<V>>::visit_with(phase, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportDecl {
-    #[doc = "Calls [Visit`::visit_import_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportDecl {
-                span,
-                specifiers,
-                src,
-                type_only,
-                with,
-                phase,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ImportSpecifier> as VisitWith<V>>::visit_with(specifiers, visitor)
-                };
-                {
-                    <Box<Str> as VisitWith<V>>::visit_with(src, visitor)
-                };
-                {
-                    <Option<Box<ObjectLit>> as VisitWith<V>>::visit_with(with, visitor)
-                };
-                {
-                    <ImportPhase as VisitWith<V>>::visit_with(phase, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportDefaultSpecifier {
-    #[doc = "Calls [Visit`::visit_import_default_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_default_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportDefaultSpecifier { span, local } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(local, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportNamedSpecifier {
-    #[doc = "Calls [Visit`::visit_import_named_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_named_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportNamedSpecifier {
-                span,
-                local,
-                imported,
-                is_type_only,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(local, visitor)
-                };
-                {
-                    <Option<ModuleExportName> as VisitWith<V>>::visit_with(imported, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportPhase {
-    #[doc = "Calls [Visit`::visit_import_phase`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_phase(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportPhase::Evaluation => {}
-            ImportPhase::Source => {}
-            ImportPhase::Defer => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportSpecifier {
-    #[doc = "Calls [Visit`::visit_import_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportSpecifier::Named { 0: _field_0 } => {
-                <ImportNamedSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ImportSpecifier::Default { 0: _field_0 } => {
-                <ImportDefaultSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ImportSpecifier::Namespace { 0: _field_0 } => {
-                <ImportStarAsSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportStarAsSpecifier {
-    #[doc = "Calls [Visit`::visit_import_star_as_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_star_as_specifier(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportStarAsSpecifier { span, local } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(local, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportWith {
-    #[doc = "Calls [Visit`::visit_import_with`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_with(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportWith { span, values } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ImportWithItem> as VisitWith<V>>::visit_with(values, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ImportWithItem {
-    #[doc = "Calls [Visit`::visit_import_with_item`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_with_item(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ImportWithItem { key, value } => {
-                {
-                    <IdentName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Str as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Invalid {
-    #[doc = "Calls [Visit`::visit_invalid`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_invalid(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Invalid { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXAttr {
-    #[doc = "Calls [Visit`::visit_jsx_attr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_attr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXAttr { span, name, value } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <JSXAttrName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<JSXAttrValue> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXAttrName {
-    #[doc = "Calls [Visit`::visit_jsx_attr_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_attr_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXAttrName::Ident { 0: _field_0 } => {
-                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXAttrName::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXAttrOrSpread {
-    #[doc = "Calls [Visit`::visit_jsx_attr_or_spread`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_attr_or_spread(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
-                <JSXAttr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
-                <SpreadElement as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXAttrValue {
-    #[doc = "Calls [Visit`::visit_jsx_attr_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_attr_value(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXAttrValue::Lit { 0: _field_0 } => {
-                <Lit as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXAttrValue::JSXExprContainer { 0: _field_0 } => {
-                <JSXExprContainer as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXAttrValue::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXAttrValue::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXClosingElement {
-    #[doc = "Calls [Visit`::visit_jsx_closing_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_closing_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXClosingElement { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <JSXElementName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXClosingFragment {
-    #[doc = "Calls [Visit`::visit_jsx_closing_fragment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_closing_fragment(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXClosingFragment { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXElement {
-    #[doc = "Calls [Visit`::visit_jsx_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXElement {
-                span,
-                opening,
-                children,
-                closing,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <JSXOpeningElement as VisitWith<V>>::visit_with(opening, visitor)
-                };
-                {
-                    <Vec<JSXElementChild> as VisitWith<V>>::visit_with(children, visitor)
-                };
-                {
-                    <Option<JSXClosingElement> as VisitWith<V>>::visit_with(closing, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXElementChild {
-    #[doc = "Calls [Visit`::visit_jsx_element_child`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_element_child(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXElementChild::JSXText { 0: _field_0 } => {
-                <JSXText as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXElementChild::JSXExprContainer { 0: _field_0 } => {
-                <JSXExprContainer as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXElementChild::JSXSpreadChild { 0: _field_0 } => {
-                <JSXSpreadChild as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXElementChild::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXElementChild::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXElementName {
-    #[doc = "Calls [Visit`::visit_jsx_element_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_element_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXElementName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXElementName::JSXMemberExpr { 0: _field_0 } => {
-                <JSXMemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXElementName::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXEmptyExpr {
-    #[doc = "Calls [Visit`::visit_jsx_empty_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_empty_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXEmptyExpr { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXExpr {
-    #[doc = "Calls [Visit`::visit_jsx_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXExpr::JSXEmptyExpr { 0: _field_0 } => {
-                <JSXEmptyExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXExprContainer {
-    #[doc = "Calls [Visit`::visit_jsx_expr_container`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_expr_container(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXExprContainer { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <JSXExpr as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXFragment {
-    #[doc = "Calls [Visit`::visit_jsx_fragment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_fragment(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXFragment {
-                span,
-                opening,
-                children,
-                closing,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <JSXOpeningFragment as VisitWith<V>>::visit_with(opening, visitor)
-                };
-                {
-                    <Vec<JSXElementChild> as VisitWith<V>>::visit_with(children, visitor)
-                };
-                {
-                    <JSXClosingFragment as VisitWith<V>>::visit_with(closing, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXMemberExpr {
-    #[doc = "Calls [Visit`::visit_jsx_member_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_member_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXMemberExpr { span, obj, prop } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <JSXObject as VisitWith<V>>::visit_with(obj, visitor)
-                };
-                {
-                    <IdentName as VisitWith<V>>::visit_with(prop, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXNamespacedName {
-    #[doc = "Calls [Visit`::visit_jsx_namespaced_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_namespaced_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXNamespacedName { span, ns, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <IdentName as VisitWith<V>>::visit_with(ns, visitor)
-                };
-                {
-                    <IdentName as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXObject {
-    #[doc = "Calls [Visit`::visit_jsx_object`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_object(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXObject::JSXMemberExpr { 0: _field_0 } => {
-                <Box<JSXMemberExpr> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            JSXObject::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXOpeningElement {
-    #[doc = "Calls [Visit`::visit_jsx_opening_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_opening_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXOpeningElement {
-                name,
-                span,
-                attrs,
-                self_closing,
-                type_args,
-            } => {
-                {
-                    <JSXElementName as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<JSXAttrOrSpread> as VisitWith<V>>::visit_with(attrs, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_args, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXOpeningFragment {
-    #[doc = "Calls [Visit`::visit_jsx_opening_fragment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_opening_fragment(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXOpeningFragment { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXSpreadChild {
-    #[doc = "Calls [Visit`::visit_jsx_spread_child`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_spread_child(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXSpreadChild { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for JSXText {
-    #[doc = "Calls [Visit`::visit_jsx_text`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_text(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            JSXText { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Key {
-    #[doc = "Calls [Visit`::visit_key`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_key(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Key::Private { 0: _field_0 } => {
-                <PrivateName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Key::Public { 0: _field_0 } => {
-                <PropName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for KeyValuePatProp {
-    #[doc = "Calls [Visit`::visit_key_value_pat_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_key_value_pat_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            KeyValuePatProp { key, value } => {
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Box<Pat> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for KeyValueProp {
-    #[doc = "Calls [Visit`::visit_key_value_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_key_value_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            KeyValueProp { key, value } => {
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for LabeledStmt {
-    #[doc = "Calls [Visit`::visit_labeled_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_labeled_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            LabeledStmt { span, label, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(label, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Lit {
-    #[doc = "Calls [Visit`::visit_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_lit(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Lit::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Lit::Bool { 0: _field_0 } => {
-                <Bool as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Lit::Null { 0: _field_0 } => {
-                <Null as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Lit::Num { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Lit::BigInt { 0: _field_0 } => {
-                <BigInt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Lit::Regex { 0: _field_0 } => {
-                <Regex as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Lit::JSXText { 0: _field_0 } => {
-                <JSXText as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MemberExpr {
-    #[doc = "Calls [Visit`::visit_member_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_member_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MemberExpr { span, obj, prop } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(obj, visitor)
-                };
-                {
-                    <MemberProp as VisitWith<V>>::visit_with(prop, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MemberProp {
-    #[doc = "Calls [Visit`::visit_member_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_member_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MemberProp::Ident { 0: _field_0 } => {
-                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MemberProp::PrivateName { 0: _field_0 } => {
-                <PrivateName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            MemberProp::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MetaPropExpr {
-    #[doc = "Calls [Visit`::visit_meta_prop_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_meta_prop_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MetaPropExpr { span, kind } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <MetaPropKind as VisitWith<V>>::visit_with(kind, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MetaPropKind {
-    #[doc = "Calls [Visit`::visit_meta_prop_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_meta_prop_kind(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MetaPropKind::NewTarget => {}
-            MetaPropKind::ImportMeta => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MethodKind {
-    #[doc = "Calls [Visit`::visit_method_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_method_kind(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MethodKind::Method => {}
-            MethodKind::Getter => {}
-            MethodKind::Setter => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for MethodProp {
-    #[doc = "Calls [Visit`::visit_method_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_method_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            MethodProp { key, function } => {
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Module {
-    #[doc = "Calls [Visit`::visit_module`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_module(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Module {
-                span,
-                body,
-                shebang,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ModuleItem> as VisitWith<V>>::visit_with(body, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(shebang, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ModuleDecl {
-    #[doc = "Calls [Visit`::visit_module_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_module_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ModuleDecl::Import { 0: _field_0 } => {
-                <ImportDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::ExportDecl { 0: _field_0 } => {
-                <ExportDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::ExportNamed { 0: _field_0 } => {
-                <NamedExport as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::ExportDefaultDecl { 0: _field_0 } => {
-                <ExportDefaultDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::ExportDefaultExpr { 0: _field_0 } => {
-                <ExportDefaultExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::ExportAll { 0: _field_0 } => {
-                <ExportAll as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::TsImportEquals { 0: _field_0 } => {
-                <Box<TsImportEqualsDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::TsExportAssignment { 0: _field_0 } => {
-                <TsExportAssignment as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleDecl::TsNamespaceExport { 0: _field_0 } => {
-                <TsNamespaceExportDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ModuleExportName {
-    #[doc = "Calls [Visit`::visit_module_export_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_module_export_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ModuleExportName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleExportName::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ModuleItem {
-    #[doc = "Calls [Visit`::visit_module_item`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_module_item(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ModuleItem::ModuleDecl { 0: _field_0 } => {
-                <ModuleDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ModuleItem::Stmt { 0: _field_0 } => {
-                <Stmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NamedExport {
-    #[doc = "Calls [Visit`::visit_named_export`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_named_export(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NamedExport {
-                span,
-                specifiers,
-                src,
-                type_only,
-                with,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ExportSpecifier> as VisitWith<V>>::visit_with(specifiers, visitor)
-                };
-                {
-                    <Option<Box<Str>> as VisitWith<V>>::visit_with(src, visitor)
-                };
-                {
-                    <Option<Box<ObjectLit>> as VisitWith<V>>::visit_with(with, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for NewExpr {
-    #[doc = "Calls [Visit`::visit_new_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_new_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            NewExpr {
-                span,
-                ctxt,
-                callee,
-                args,
-                type_args,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(callee, visitor)
-                };
-                {
-                    <Option<Vec<ExprOrSpread>> as VisitWith<V>>::visit_with(args, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_args, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Null {
-    #[doc = "Calls [Visit`::visit_null`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_null(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Null { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Number {
-    #[doc = "Calls [Visit`::visit_number`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_number(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Number { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ObjectLit {
-    #[doc = "Calls [Visit`::visit_object_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_object_lit(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ObjectLit { span, props } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<PropOrSpread> as VisitWith<V>>::visit_with(props, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ObjectPat {
-    #[doc = "Calls [Visit`::visit_object_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_object_pat(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ObjectPat {
-                span,
-                props,
-                optional,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ObjectPatProp> as VisitWith<V>>::visit_with(props, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ObjectPatProp {
-    #[doc = "Calls [Visit`::visit_object_pat_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_object_pat_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ObjectPatProp::KeyValue { 0: _field_0 } => {
-                <KeyValuePatProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ObjectPatProp::Assign { 0: _field_0 } => {
-                <AssignPatProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ObjectPatProp::Rest { 0: _field_0 } => {
-                <RestPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for OptCall {
-    #[doc = "Calls [Visit`::visit_opt_call`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_call(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            OptCall {
-                span,
-                ctxt,
-                callee,
-                args,
-                type_args,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(callee, visitor)
-                };
-                {
-                    <Vec<ExprOrSpread> as VisitWith<V>>::visit_with(args, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_args, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for OptChainBase {
-    #[doc = "Calls [Visit`::visit_opt_chain_base`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_chain_base(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            OptChainBase::Member { 0: _field_0 } => {
-                <MemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            OptChainBase::Call { 0: _field_0 } => {
-                <OptCall as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for OptChainExpr {
-    #[doc = "Calls [Visit`::visit_opt_chain_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_chain_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            OptChainExpr {
-                span,
-                optional,
-                base,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<OptChainBase> as VisitWith<V>>::visit_with(base, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Param {
-    #[doc = "Calls [Visit`::visit_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_param(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Param {
-                span,
-                decorators,
-                pat,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
-                };
-                {
-                    <Pat as VisitWith<V>>::visit_with(pat, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ParamOrTsParamProp {
-    #[doc = "Calls [Visit`::visit_param_or_ts_param_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_param_or_ts_param_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ParamOrTsParamProp::TsParamProp { 0: _field_0 } => {
-                <TsParamProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            ParamOrTsParamProp::Param { 0: _field_0 } => {
-                <Param as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ParenExpr {
-    #[doc = "Calls [Visit`::visit_paren_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_paren_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ParenExpr { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Pat {
-    #[doc = "Calls [Visit`::visit_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pat(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Pat::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Pat::Array { 0: _field_0 } => {
-                <ArrayPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Pat::Rest { 0: _field_0 } => {
-                <RestPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Pat::Object { 0: _field_0 } => {
-                <ObjectPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Pat::Assign { 0: _field_0 } => {
-                <AssignPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Pat::Invalid { 0: _field_0 } => {
-                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Pat::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PrivateMethod {
-    #[doc = "Calls [Visit`::visit_private_method`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_private_method(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PrivateMethod {
-                span,
-                key,
-                function,
-                kind,
-                is_static,
-                accessibility,
-                is_abstract,
-                is_optional,
-                is_override,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <PrivateName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
-                };
-                {
-                    <MethodKind as VisitWith<V>>::visit_with(kind, visitor)
-                };
-                {
-                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PrivateName {
-    #[doc = "Calls [Visit`::visit_private_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_private_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PrivateName { span, name } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(name, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PrivateProp {
-    #[doc = "Calls [Visit`::visit_private_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_private_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PrivateProp {
-                span,
-                ctxt,
-                key,
-                value,
-                type_ann,
-                is_static,
-                decorators,
-                accessibility,
-                is_optional,
-                is_override,
-                readonly,
-                definite,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <PrivateName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
-                };
-                {
-                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Program {
-    #[doc = "Calls [Visit`::visit_program`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_program(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Program::Module { 0: _field_0 } => {
-                <Module as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Program::Script { 0: _field_0 } => {
-                <Script as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Prop {
-    #[doc = "Calls [Visit`::visit_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Prop::Shorthand { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Prop::KeyValue { 0: _field_0 } => {
-                <KeyValueProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Prop::Assign { 0: _field_0 } => {
-                <AssignProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Prop::Getter { 0: _field_0 } => {
-                <GetterProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Prop::Setter { 0: _field_0 } => {
-                <SetterProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Prop::Method { 0: _field_0 } => {
-                <MethodProp as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PropName {
-    #[doc = "Calls [Visit`::visit_prop_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_prop_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PropName::Ident { 0: _field_0 } => {
-                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PropName::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PropName::Num { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PropName::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PropName::BigInt { 0: _field_0 } => {
-                <BigInt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for PropOrSpread {
-    #[doc = "Calls [Visit`::visit_prop_or_spread`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_prop_or_spread(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            PropOrSpread::Spread { 0: _field_0 } => {
-                <SpreadElement as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            PropOrSpread::Prop { 0: _field_0 } => {
-                <Box<Prop> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Regex {
-    #[doc = "Calls [Visit`::visit_regex`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_regex(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Regex { span, exp, flags } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(exp, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(flags, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for RestPat {
-    #[doc = "Calls [Visit`::visit_rest_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_rest_pat(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            RestPat {
-                span,
-                dot3_token,
-                arg,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(dot3_token, visitor)
-                };
-                {
-                    <Box<Pat> as VisitWith<V>>::visit_with(arg, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ReturnStmt {
-    #[doc = "Calls [Visit`::visit_return_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_return_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ReturnStmt { span, arg } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(arg, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Script {
-    #[doc = "Calls [Visit`::visit_script`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_script(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Script {
-                span,
-                body,
-                shebang,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(shebang, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SeqExpr {
-    #[doc = "Calls [Visit`::visit_seq_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_seq_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SeqExpr { span, exprs } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Box<Expr>> as VisitWith<V>>::visit_with(exprs, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SetterProp {
-    #[doc = "Calls [Visit`::visit_setter_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_setter_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SetterProp {
-                span,
-                key,
-                this_param,
-                param,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <PropName as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Pat> as VisitWith<V>>::visit_with(this_param, visitor)
-                };
-                {
-                    <Box<Pat> as VisitWith<V>>::visit_with(param, visitor)
-                };
-                {
-                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SimpleAssignTarget {
-    #[doc = "Calls [Visit`::visit_simple_assign_target`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_simple_assign_target(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SimpleAssignTarget::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::Member { 0: _field_0 } => {
-                <MemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::SuperProp { 0: _field_0 } => {
-                <SuperPropExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::Paren { 0: _field_0 } => {
-                <ParenExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::OptChain { 0: _field_0 } => {
-                <OptChainExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::TsAs { 0: _field_0 } => {
-                <TsAsExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::TsSatisfies { 0: _field_0 } => {
-                <TsSatisfiesExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::TsNonNull { 0: _field_0 } => {
-                <TsNonNullExpr as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::TsTypeAssertion { 0: _field_0 } => {
-                <TsTypeAssertion as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::TsInstantiation { 0: _field_0 } => {
-                <TsInstantiation as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SimpleAssignTarget::Invalid { 0: _field_0 } => {
-                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SpreadElement {
-    #[doc = "Calls [Visit`::visit_spread_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_spread_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SpreadElement { dot3_token, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(dot3_token, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for StaticBlock {
-    #[doc = "Calls [Visit`::visit_static_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_static_block(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            StaticBlock { span, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <BlockStmt as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Stmt {
-    #[doc = "Calls [Visit`::visit_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Stmt::Block { 0: _field_0 } => {
-                <BlockStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Empty { 0: _field_0 } => {
-                <EmptyStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Debugger { 0: _field_0 } => {
-                <DebuggerStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::With { 0: _field_0 } => {
-                <WithStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Return { 0: _field_0 } => {
-                <ReturnStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Labeled { 0: _field_0 } => {
-                <LabeledStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Break { 0: _field_0 } => {
-                <BreakStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Continue { 0: _field_0 } => {
-                <ContinueStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::If { 0: _field_0 } => {
-                <IfStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Switch { 0: _field_0 } => {
-                <SwitchStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Throw { 0: _field_0 } => {
-                <ThrowStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Try { 0: _field_0 } => {
-                <Box<TryStmt> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::While { 0: _field_0 } => {
-                <WhileStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::DoWhile { 0: _field_0 } => {
-                <DoWhileStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::For { 0: _field_0 } => {
-                <ForStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::ForIn { 0: _field_0 } => {
-                <ForInStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::ForOf { 0: _field_0 } => {
-                <ForOfStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Decl { 0: _field_0 } => {
-                <Decl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            Stmt::Expr { 0: _field_0 } => {
-                <ExprStmt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Str {
-    #[doc = "Calls [Visit`::visit_str`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_str(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Str { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Super {
-    #[doc = "Calls [Visit`::visit_super`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_super(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Super { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SuperProp {
-    #[doc = "Calls [Visit`::visit_super_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_super_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SuperProp::Ident { 0: _field_0 } => {
-                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            SuperProp::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SuperPropExpr {
-    #[doc = "Calls [Visit`::visit_super_prop_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_super_prop_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SuperPropExpr { span, obj, prop } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Super as VisitWith<V>>::visit_with(obj, visitor)
-                };
-                {
-                    <SuperProp as VisitWith<V>>::visit_with(prop, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SwitchCase {
-    #[doc = "Calls [Visit`::visit_switch_case`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_switch_case(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SwitchCase { span, test, cons } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(test, visitor)
-                };
-                {
-                    <Vec<Stmt> as VisitWith<V>>::visit_with(cons, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for SwitchStmt {
-    #[doc = "Calls [Visit`::visit_switch_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_switch_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            SwitchStmt {
-                span,
-                discriminant,
-                cases,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(discriminant, visitor)
-                };
-                {
-                    <Vec<SwitchCase> as VisitWith<V>>::visit_with(cases, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TaggedTpl {
-    #[doc = "Calls [Visit`::visit_tagged_tpl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_tagged_tpl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TaggedTpl {
-                span,
-                ctxt,
-                tag,
-                type_params,
-                tpl,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(tag, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_params,
-                        visitor,
-                    )
-                };
-                {
-                    <Box<Tpl> as VisitWith<V>>::visit_with(tpl, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ThisExpr {
-    #[doc = "Calls [Visit`::visit_this_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_this_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ThisExpr { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for ThrowStmt {
-    #[doc = "Calls [Visit`::visit_throw_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_throw_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ThrowStmt { span, arg } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Tpl {
-    #[doc = "Calls [Visit`::visit_tpl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_tpl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Tpl {
-                span,
-                exprs,
-                quasis,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Box<Expr>> as VisitWith<V>>::visit_with(exprs, visitor)
-                };
-                {
-                    <Vec<TplElement> as VisitWith<V>>::visit_with(quasis, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TplElement {
-    #[doc = "Calls [Visit`::visit_tpl_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_tpl_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TplElement {
-                span,
-                tail,
-                cooked,
-                raw,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(cooked, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TruePlusMinus {
-    #[doc = "Calls [Visit`::visit_true_plus_minus`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_true_plus_minus(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TruePlusMinus::True => {}
-            TruePlusMinus::Plus => {}
-            TruePlusMinus::Minus => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TryStmt {
-    #[doc = "Calls [Visit`::visit_try_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_try_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TryStmt {
-                span,
-                block,
-                handler,
-                finalizer,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <BlockStmt as VisitWith<V>>::visit_with(block, visitor)
-                };
-                {
-                    <Option<CatchClause> as VisitWith<V>>::visit_with(handler, visitor)
-                };
-                {
-                    <Option<BlockStmt> as VisitWith<V>>::visit_with(finalizer, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsArrayType {
-    #[doc = "Calls [Visit`::visit_ts_array_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_array_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsArrayType { span, elem_type } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(elem_type, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsAsExpr {
-    #[doc = "Calls [Visit`::visit_ts_as_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_as_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsAsExpr {
-                span,
-                expr,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsCallSignatureDecl {
-    #[doc = "Calls [Visit`::visit_ts_call_signature_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_call_signature_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsCallSignatureDecl {
-                span,
-                params,
-                type_ann,
-                type_params,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsConditionalType {
-    #[doc = "Calls [Visit`::visit_ts_conditional_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_conditional_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsConditionalType {
-                span,
-                check_type,
-                extends_type,
-                true_type,
-                false_type,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(check_type, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(extends_type, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(true_type, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(false_type, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsConstAssertion {
-    #[doc = "Calls [Visit`::visit_ts_const_assertion`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_const_assertion(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsConstAssertion { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsConstructSignatureDecl {
-    #[doc = "Calls [Visit`::visit_ts_construct_signature_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_construct_signature_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsConstructSignatureDecl {
-                span,
-                params,
-                type_ann,
-                type_params,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsConstructorType {
-    #[doc = "Calls [Visit`::visit_ts_constructor_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_constructor_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsConstructorType {
-                span,
-                params,
-                type_params,
-                type_ann,
-                is_abstract,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-                {
-                    <Box<TsTypeAnn> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsEntityName {
-    #[doc = "Calls [Visit`::visit_ts_entity_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_entity_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsEntityName::TsQualifiedName { 0: _field_0 } => {
-                <Box<TsQualifiedName> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsEntityName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsEnumDecl {
-    #[doc = "Calls [Visit`::visit_ts_enum_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_enum_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsEnumDecl {
-                span,
-                declare,
-                is_const,
-                id,
-                members,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <Vec<TsEnumMember> as VisitWith<V>>::visit_with(members, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsEnumMember {
-    #[doc = "Calls [Visit`::visit_ts_enum_member`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_enum_member(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsEnumMember { span, id, init } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsEnumMemberId as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(init, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsEnumMemberId {
-    #[doc = "Calls [Visit`::visit_ts_enum_member_id`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_enum_member_id(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsEnumMemberId::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsEnumMemberId::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsExportAssignment {
-    #[doc = "Calls [Visit`::visit_ts_export_assignment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_export_assignment(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsExportAssignment { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsExprWithTypeArgs {
-    #[doc = "Calls [Visit`::visit_ts_expr_with_type_args`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_expr_with_type_args(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsExprWithTypeArgs {
-                span,
-                expr,
-                type_args,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_args, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsExternalModuleRef {
-    #[doc = "Calls [Visit`::visit_ts_external_module_ref`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_external_module_ref(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsExternalModuleRef { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Str as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsFnOrConstructorType {
-    #[doc = "Calls [Visit`::visit_ts_fn_or_constructor_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_fn_or_constructor_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsFnOrConstructorType::TsFnType { 0: _field_0 } => {
-                <TsFnType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsFnOrConstructorType::TsConstructorType { 0: _field_0 } => {
-                <TsConstructorType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsFnParam {
-    #[doc = "Calls [Visit`::visit_ts_fn_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_fn_param(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsFnParam::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsFnParam::Array { 0: _field_0 } => {
-                <ArrayPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsFnParam::Rest { 0: _field_0 } => {
-                <RestPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsFnParam::Object { 0: _field_0 } => {
-                <ObjectPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsFnType {
-    #[doc = "Calls [Visit`::visit_ts_fn_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_fn_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsFnType {
-                span,
-                params,
-                type_params,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-                {
-                    <Box<TsTypeAnn> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsGetterSignature {
-    #[doc = "Calls [Visit`::visit_ts_getter_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_getter_signature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsGetterSignature {
-                span,
-                key,
-                computed,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsImportEqualsDecl {
-    #[doc = "Calls [Visit`::visit_ts_import_equals_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_import_equals_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsImportEqualsDecl {
-                span,
-                is_export,
-                is_type_only,
-                id,
-                module_ref,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <TsModuleRef as VisitWith<V>>::visit_with(module_ref, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsImportType {
-    #[doc = "Calls [Visit`::visit_ts_import_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_import_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsImportType {
-                span,
-                arg,
-                qualifier,
-                type_args,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Str as VisitWith<V>>::visit_with(arg, visitor)
-                };
-                {
-                    <Option<TsEntityName> as VisitWith<V>>::visit_with(qualifier, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_args, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsIndexSignature {
-    #[doc = "Calls [Visit`::visit_ts_index_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_index_signature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsIndexSignature {
-                params,
-                type_ann,
-                readonly,
-                is_static,
-                span,
-            } => {
-                {
-                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsIndexedAccessType {
-    #[doc = "Calls [Visit`::visit_ts_indexed_access_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_indexed_access_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsIndexedAccessType {
-                span,
-                readonly,
-                obj_type,
-                index_type,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(obj_type, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(index_type, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsInferType {
-    #[doc = "Calls [Visit`::visit_ts_infer_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_infer_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsInferType { span, type_param } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsTypeParam as VisitWith<V>>::visit_with(type_param, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsInstantiation {
-    #[doc = "Calls [Visit`::visit_ts_instantiation`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_instantiation(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsInstantiation {
-                span,
-                expr,
-                type_args,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-                {
-                    <Box<TsTypeParamInstantiation> as VisitWith<V>>::visit_with(type_args, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsInterfaceBody {
-    #[doc = "Calls [Visit`::visit_ts_interface_body`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_interface_body(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsInterfaceBody { span, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsTypeElement> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsInterfaceDecl {
-    #[doc = "Calls [Visit`::visit_ts_interface_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_interface_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsInterfaceDecl {
-                span,
-                id,
-                declare,
-                type_params,
-                extends,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-                {
-                    <Vec<TsExprWithTypeArgs> as VisitWith<V>>::visit_with(extends, visitor)
-                };
-                {
-                    <TsInterfaceBody as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsIntersectionType {
-    #[doc = "Calls [Visit`::visit_ts_intersection_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_intersection_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsIntersectionType { span, types } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(types, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsKeywordType {
-    #[doc = "Calls [Visit`::visit_ts_keyword_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_keyword_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsKeywordType { span, kind } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsKeywordTypeKind as VisitWith<V>>::visit_with(kind, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsKeywordTypeKind {
-    #[doc = "Calls [Visit`::visit_ts_keyword_type_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_keyword_type_kind(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsKeywordTypeKind::TsAnyKeyword => {}
-            TsKeywordTypeKind::TsUnknownKeyword => {}
-            TsKeywordTypeKind::TsNumberKeyword => {}
-            TsKeywordTypeKind::TsObjectKeyword => {}
-            TsKeywordTypeKind::TsBooleanKeyword => {}
-            TsKeywordTypeKind::TsBigIntKeyword => {}
-            TsKeywordTypeKind::TsStringKeyword => {}
-            TsKeywordTypeKind::TsSymbolKeyword => {}
-            TsKeywordTypeKind::TsVoidKeyword => {}
-            TsKeywordTypeKind::TsUndefinedKeyword => {}
-            TsKeywordTypeKind::TsNullKeyword => {}
-            TsKeywordTypeKind::TsNeverKeyword => {}
-            TsKeywordTypeKind::TsIntrinsicKeyword => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsLit {
-    #[doc = "Calls [Visit`::visit_ts_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_lit(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsLit::Number { 0: _field_0 } => {
-                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsLit::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsLit::Bool { 0: _field_0 } => {
-                <Bool as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsLit::BigInt { 0: _field_0 } => {
-                <BigInt as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsLit::Tpl { 0: _field_0 } => {
-                <TsTplLitType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsLitType {
-    #[doc = "Calls [Visit`::visit_ts_lit_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_lit_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsLitType { span, lit } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsLit as VisitWith<V>>::visit_with(lit, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsMappedType {
-    #[doc = "Calls [Visit`::visit_ts_mapped_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_mapped_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsMappedType {
-                span,
-                readonly,
-                type_param,
-                name_type,
-                optional,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<TruePlusMinus> as VisitWith<V>>::visit_with(readonly, visitor)
-                };
-                {
-                    <TsTypeParam as VisitWith<V>>::visit_with(type_param, visitor)
-                };
-                {
-                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(name_type, visitor)
-                };
-                {
-                    <Option<TruePlusMinus> as VisitWith<V>>::visit_with(optional, visitor)
-                };
-                {
-                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsMethodSignature {
-    #[doc = "Calls [Visit`::visit_ts_method_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_method_signature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsMethodSignature {
-                span,
-                key,
-                computed,
-                optional,
-                params,
-                type_ann,
-                type_params,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsModuleBlock {
-    #[doc = "Calls [Visit`::visit_ts_module_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_module_block(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsModuleBlock { span, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<ModuleItem> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsModuleDecl {
-    #[doc = "Calls [Visit`::visit_ts_module_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_module_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsModuleDecl {
-                span,
-                declare,
-                global,
-                id,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsModuleName as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <Option<TsNamespaceBody> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsModuleName {
-    #[doc = "Calls [Visit`::visit_ts_module_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_module_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsModuleName::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsModuleName::Str { 0: _field_0 } => {
-                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsModuleRef {
-    #[doc = "Calls [Visit`::visit_ts_module_ref`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_module_ref(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsModuleRef::TsEntityName { 0: _field_0 } => {
-                <TsEntityName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsModuleRef::TsExternalModuleRef { 0: _field_0 } => {
-                <TsExternalModuleRef as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsNamespaceBody {
-    #[doc = "Calls [Visit`::visit_ts_namespace_body`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_namespace_body(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsNamespaceBody::TsModuleBlock { 0: _field_0 } => {
-                <TsModuleBlock as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsNamespaceBody::TsNamespaceDecl { 0: _field_0 } => {
-                <TsNamespaceDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsNamespaceDecl {
-    #[doc = "Calls [Visit`::visit_ts_namespace_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_namespace_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsNamespaceDecl {
-                span,
-                declare,
-                global,
-                id,
-                body,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <Box<TsNamespaceBody> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsNamespaceExportDecl {
-    #[doc = "Calls [Visit`::visit_ts_namespace_export_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_namespace_export_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsNamespaceExportDecl { span, id } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(id, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsNonNullExpr {
-    #[doc = "Calls [Visit`::visit_ts_non_null_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_non_null_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsNonNullExpr { span, expr } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsOptionalType {
-    #[doc = "Calls [Visit`::visit_ts_optional_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_optional_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsOptionalType { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsParamProp {
-    #[doc = "Calls [Visit`::visit_ts_param_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_param_prop(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsParamProp {
-                span,
-                decorators,
-                accessibility,
-                is_override,
-                readonly,
-                param,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
-                };
-                {
-                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
-                };
-                {
-                    <TsParamPropParam as VisitWith<V>>::visit_with(param, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsParamPropParam {
-    #[doc = "Calls [Visit`::visit_ts_param_prop_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_param_prop_param(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsParamPropParam::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsParamPropParam::Assign { 0: _field_0 } => {
-                <AssignPat as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsParenthesizedType {
-    #[doc = "Calls [Visit`::visit_ts_parenthesized_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_parenthesized_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsParenthesizedType { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsPropertySignature {
-    #[doc = "Calls [Visit`::visit_ts_property_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_property_signature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsPropertySignature {
-                span,
-                readonly,
-                key,
-                computed,
-                optional,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsQualifiedName {
-    #[doc = "Calls [Visit`::visit_ts_qualified_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_qualified_name(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsQualifiedName { span, left, right } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsEntityName as VisitWith<V>>::visit_with(left, visitor)
-                };
-                {
-                    <IdentName as VisitWith<V>>::visit_with(right, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsRestType {
-    #[doc = "Calls [Visit`::visit_ts_rest_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_rest_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsRestType { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsSatisfiesExpr {
-    #[doc = "Calls [Visit`::visit_ts_satisfies_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_satisfies_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsSatisfiesExpr {
-                span,
-                expr,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsSetterSignature {
-    #[doc = "Calls [Visit`::visit_ts_setter_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_setter_signature(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsSetterSignature {
-                span,
-                key,
-                computed,
-                param,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
-                };
-                {
-                    <TsFnParam as VisitWith<V>>::visit_with(param, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsThisType {
-    #[doc = "Calls [Visit`::visit_ts_this_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_this_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsThisType { span } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsThisTypeOrIdent {
-    #[doc = "Calls [Visit`::visit_ts_this_type_or_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_this_type_or_ident(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsThisTypeOrIdent::TsThisType { 0: _field_0 } => {
-                <TsThisType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsThisTypeOrIdent::Ident { 0: _field_0 } => {
-                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTplLitType {
-    #[doc = "Calls [Visit`::visit_ts_tpl_lit_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_tpl_lit_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTplLitType {
-                span,
-                types,
-                quasis,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(types, visitor)
-                };
-                {
-                    <Vec<TplElement> as VisitWith<V>>::visit_with(quasis, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTupleElement {
-    #[doc = "Calls [Visit`::visit_ts_tuple_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_tuple_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTupleElement { span, label, ty } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Pat> as VisitWith<V>>::visit_with(label, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(ty, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTupleType {
-    #[doc = "Calls [Visit`::visit_ts_tuple_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_tuple_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTupleType { span, elem_types } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsTupleElement> as VisitWith<V>>::visit_with(elem_types, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsType {
-    #[doc = "Calls [Visit`::visit_ts_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsType::TsKeywordType { 0: _field_0 } => {
-                <TsKeywordType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsThisType { 0: _field_0 } => {
-                <TsThisType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsFnOrConstructorType { 0: _field_0 } => {
-                <TsFnOrConstructorType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsTypeRef { 0: _field_0 } => {
-                <TsTypeRef as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsTypeQuery { 0: _field_0 } => {
-                <TsTypeQuery as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsTypeLit { 0: _field_0 } => {
-                <TsTypeLit as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsArrayType { 0: _field_0 } => {
-                <TsArrayType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsTupleType { 0: _field_0 } => {
-                <TsTupleType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsOptionalType { 0: _field_0 } => {
-                <TsOptionalType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsRestType { 0: _field_0 } => {
-                <TsRestType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsUnionOrIntersectionType { 0: _field_0 } => {
-                <TsUnionOrIntersectionType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsConditionalType { 0: _field_0 } => {
-                <TsConditionalType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsInferType { 0: _field_0 } => {
-                <TsInferType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsParenthesizedType { 0: _field_0 } => {
-                <TsParenthesizedType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsTypeOperator { 0: _field_0 } => {
-                <TsTypeOperator as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsIndexedAccessType { 0: _field_0 } => {
-                <TsIndexedAccessType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsMappedType { 0: _field_0 } => {
-                <TsMappedType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsLitType { 0: _field_0 } => {
-                <TsLitType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsTypePredicate { 0: _field_0 } => {
-                <TsTypePredicate as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsType::TsImportType { 0: _field_0 } => {
-                <TsImportType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeAliasDecl {
-    #[doc = "Calls [Visit`::visit_ts_type_alias_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_alias_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeAliasDecl {
-                span,
-                declare,
-                id,
-                type_params,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(id, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeAnn {
-    #[doc = "Calls [Visit`::visit_ts_type_ann`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_ann(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeAnn { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeAssertion {
-    #[doc = "Calls [Visit`::visit_ts_type_assertion`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_assertion(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeAssertion {
-                span,
-                expr,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeElement {
-    #[doc = "Calls [Visit`::visit_ts_type_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeElement::TsCallSignatureDecl { 0: _field_0 } => {
-                <TsCallSignatureDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsTypeElement::TsConstructSignatureDecl { 0: _field_0 } => {
-                <TsConstructSignatureDecl as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsTypeElement::TsPropertySignature { 0: _field_0 } => {
-                <TsPropertySignature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsTypeElement::TsGetterSignature { 0: _field_0 } => {
-                <TsGetterSignature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsTypeElement::TsSetterSignature { 0: _field_0 } => {
-                <TsSetterSignature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsTypeElement::TsMethodSignature { 0: _field_0 } => {
-                <TsMethodSignature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsTypeElement::TsIndexSignature { 0: _field_0 } => {
-                <TsIndexSignature as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeLit {
-    #[doc = "Calls [Visit`::visit_ts_type_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_lit(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeLit { span, members } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsTypeElement> as VisitWith<V>>::visit_with(members, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeOperator {
-    #[doc = "Calls [Visit`::visit_ts_type_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_operator(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeOperator { span, op, type_ann } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsTypeOperatorOp as VisitWith<V>>::visit_with(op, visitor)
-                };
-                {
-                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeOperatorOp {
-    #[doc = "Calls [Visit`::visit_ts_type_operator_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_operator_op(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeOperatorOp::KeyOf => {}
-            TsTypeOperatorOp::Unique => {}
-            TsTypeOperatorOp::ReadOnly => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeParam {
-    #[doc = "Calls [Visit`::visit_ts_type_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_param(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeParam {
-                span,
-                name,
-                is_in,
-                is_out,
-                is_const,
-                constraint,
-                default,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Ident as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(constraint, visitor)
-                };
-                {
-                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(default, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeParamDecl {
-    #[doc = "Calls [Visit`::visit_ts_type_param_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_param_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeParamDecl { span, params } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<TsTypeParam> as VisitWith<V>>::visit_with(params, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeParamInstantiation {
-    #[doc = "Calls [Visit`::visit_ts_type_param_instantiation`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_param_instantiation(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeParamInstantiation { span, params } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(params, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypePredicate {
-    #[doc = "Calls [Visit`::visit_ts_type_predicate`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_predicate(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypePredicate {
-                span,
-                asserts,
-                param_name,
-                type_ann,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsThisTypeOrIdent as VisitWith<V>>::visit_with(param_name, visitor)
-                };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeQuery {
-    #[doc = "Calls [Visit`::visit_ts_type_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_query(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeQuery {
-                span,
-                expr_name,
-                type_args,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsTypeQueryExpr as VisitWith<V>>::visit_with(expr_name, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_args, visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeQueryExpr {
-    #[doc = "Calls [Visit`::visit_ts_type_query_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_query_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeQueryExpr::TsEntityName { 0: _field_0 } => {
-                <TsEntityName as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsTypeQueryExpr::Import { 0: _field_0 } => {
-                <TsImportType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsTypeRef {
-    #[doc = "Calls [Visit`::visit_ts_type_ref`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_ref(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsTypeRef {
-                span,
-                type_name,
-                type_params,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsEntityName as VisitWith<V>>::visit_with(type_name, visitor)
-                };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
-                        type_params,
-                        visitor,
-                    )
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsUnionOrIntersectionType {
-    #[doc = "Calls [Visit`::visit_ts_union_or_intersection_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_union_or_intersection_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsUnionOrIntersectionType::TsUnionType { 0: _field_0 } => {
-                <TsUnionType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 } => {
-                <TsIntersectionType as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for TsUnionType {
-    #[doc = "Calls [Visit`::visit_ts_union_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_union_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TsUnionType { span, types } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(types, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UnaryExpr {
-    #[doc = "Calls [Visit`::visit_unary_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_unary_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UnaryExpr { span, op, arg } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <UnaryOp as VisitWith<V>>::visit_with(op, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UnaryOp {
-    #[doc = "Calls [Visit`::visit_unary_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_unary_op(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UnaryOp::Minus => {}
-            UnaryOp::Plus => {}
-            UnaryOp::Bang => {}
-            UnaryOp::Tilde => {}
-            UnaryOp::TypeOf => {}
-            UnaryOp::Void => {}
-            UnaryOp::Delete => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UpdateExpr {
-    #[doc = "Calls [Visit`::visit_update_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_update_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UpdateExpr {
-                span,
-                op,
-                prefix,
-                arg,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <UpdateOp as VisitWith<V>>::visit_with(op, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UpdateOp {
-    #[doc = "Calls [Visit`::visit_update_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_update_op(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UpdateOp::PlusPlus => {}
-            UpdateOp::MinusMinus => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for UsingDecl {
-    #[doc = "Calls [Visit`::visit_using_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_using_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            UsingDecl {
-                span,
-                is_await,
-                decls,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<VarDeclarator> as VisitWith<V>>::visit_with(decls, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for VarDecl {
-    #[doc = "Calls [Visit`::visit_var_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_var_decl(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            VarDecl {
-                span,
-                ctxt,
-                kind,
-                declare,
-                decls,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
-                };
-                {
-                    <VarDeclKind as VisitWith<V>>::visit_with(kind, visitor)
-                };
-                {
-                    <Vec<VarDeclarator> as VisitWith<V>>::visit_with(decls, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for VarDeclKind {
-    #[doc = "Calls [Visit`::visit_var_decl_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_var_decl_kind(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            VarDeclKind::Var => {}
-            VarDeclKind::Let => {}
-            VarDeclKind::Const => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for VarDeclOrExpr {
-    #[doc = "Calls [Visit`::visit_var_decl_or_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_var_decl_or_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            VarDeclOrExpr::VarDecl { 0: _field_0 } => {
-                <Box<VarDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-            VarDeclOrExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for VarDeclarator {
-    #[doc = "Calls [Visit`::visit_var_declarator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_var_declarator(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            VarDeclarator {
-                span,
-                name,
-                init,
-                definite,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Pat as VisitWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(init, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for WhileStmt {
-    #[doc = "Calls [Visit`::visit_while_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_while_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            WhileStmt { span, test, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for WithStmt {
-    #[doc = "Calls [Visit`::visit_with_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_with_stmt(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            WithStmt { span, obj, body } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitWith<V>>::visit_with(obj, visitor)
-                };
-                {
-                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for YieldExpr {
-    #[doc = "Calls [Visit`::visit_yield_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_yield_expr(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            YieldExpr {
-                span,
-                arg,
-                delegate,
-            } => {
-                {
-                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(arg, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [Visit`::visit_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for BigIntValue {
-    #[doc = "Calls [Visit`::visit_big_int_value`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_big_int_value(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ClassMember] {
-    #[doc = "Calls [Visit`::visit_class_members`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_class_members(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ClassMember as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Decorator] {
-    #[doc = "Calls [Visit`::visit_decorators`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_decorators(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Decorator as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ExportSpecifier] {
-    #[doc = "Calls [Visit`::visit_export_specifiers`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_export_specifiers(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ExportSpecifier as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ExprOrSpread] {
-    #[doc = "Calls [Visit`::visit_expr_or_spreads`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_expr_or_spreads(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ExprOrSpread as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Box<Expr>] {
-    #[doc = "Calls [Visit`::visit_exprs`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_exprs(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Box<Expr> as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ImportSpecifier] {
-    #[doc = "Calls [Visit`::visit_import_specifiers`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_specifiers(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ImportSpecifier as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ImportWithItem] {
-    #[doc = "Calls [Visit`::visit_import_with_items`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_import_with_items(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ImportWithItem as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [JSXAttrOrSpread] {
-    #[doc = "Calls [Visit`::visit_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_attr_or_spreads(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <JSXAttrOrSpread as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [JSXElementChild] {
-    #[doc = "Calls [Visit`::visit_jsx_element_childs`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_jsx_element_childs(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <JSXElementChild as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ModuleItem] {
-    #[doc = "Calls [Visit`::visit_module_items`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_module_items(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ModuleItem as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ObjectPatProp] {
-    #[doc = "Calls [Visit`::visit_object_pat_props`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_object_pat_props(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ObjectPatProp as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Accessibility> {
-    #[doc = "Calls [Visit`::visit_opt_accessibility`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_accessibility(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Accessibility as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [Visit`::visit_opt_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_atoms::Atom as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<BlockStmt> {
-    #[doc = "Calls [Visit`::visit_opt_block_stmt`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_block_stmt(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <BlockStmt as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<CatchClause> {
-    #[doc = "Calls [Visit`::visit_opt_catch_clause`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_catch_clause(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <CatchClause as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Expr>> {
-    #[doc = "Calls [Visit`::visit_opt_expr`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_expr(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Expr> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<ExprOrSpread> {
-    #[doc = "Calls [Visit`::visit_opt_expr_or_spread`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_expr_or_spread(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ExprOrSpread as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<ExprOrSpread>> {
-    #[doc = "Calls [Visit`::visit_opt_expr_or_spreads`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_expr_or_spreads(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Vec<ExprOrSpread> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Ident> {
-    #[doc = "Calls [Visit`::visit_opt_ident`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ident(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Ident as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<JSXAttrValue> {
-    #[doc = "Calls [Visit`::visit_opt_jsx_attr_value`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_jsx_attr_value(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <JSXAttrValue as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<JSXClosingElement> {
-    #[doc = "Calls [Visit`::visit_opt_jsx_closing_element`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_jsx_closing_element(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <JSXClosingElement as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<ModuleExportName> {
-    #[doc = "Calls [Visit`::visit_opt_module_export_name`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_module_export_name(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ModuleExportName as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ObjectLit>> {
-    #[doc = "Calls [Visit`::visit_opt_object_lit`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_object_lit(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<ObjectLit> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Pat> {
-    #[doc = "Calls [Visit`::visit_opt_pat`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_pat(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Pat as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_common::Span> {
-    #[doc = "Calls [Visit`::visit_opt_span`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_span(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_common::Span as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Stmt>> {
-    #[doc = "Calls [Visit`::visit_opt_stmt`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_stmt(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Stmt> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Str>> {
-    #[doc = "Calls [Visit`::visit_opt_str`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_str(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Str> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<TruePlusMinus> {
-    #[doc = "Calls [Visit`::visit_opt_true_plus_minus`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_true_plus_minus(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <TruePlusMinus as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<TsEntityName> {
-    #[doc = "Calls [Visit`::visit_opt_ts_entity_name`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ts_entity_name(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <TsEntityName as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<TsNamespaceBody> {
-    #[doc = "Calls [Visit`::visit_opt_ts_namespace_body`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ts_namespace_body(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <TsNamespaceBody as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsType>> {
-    #[doc = "Calls [Visit`::visit_opt_ts_type`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ts_type(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TsType> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeAnn>> {
-    #[doc = "Calls [Visit`::visit_opt_ts_type_ann`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ts_type_ann(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TsTypeAnn> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeParamDecl>> {
-    #[doc = "Calls [Visit`::visit_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ts_type_param_decl(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TsTypeParamDecl> as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeParamInstantiation>> {
-    #[doc = "Calls [Visit`::visit_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_ts_type_param_instantiation(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <Box<TsTypeParamInstantiation> as VisitWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for Option<VarDeclOrExpr> {
-    #[doc = "Calls [Visit`::visit_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_var_decl_or_expr(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <VarDeclOrExpr as VisitWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Option<ExprOrSpread>] {
-    #[doc = "Calls [Visit`::visit_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_vec_expr_or_spreads(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Option<ExprOrSpread> as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Option<Pat>] {
-    #[doc = "Calls [Visit`::visit_opt_vec_pats`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_opt_vec_pats(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Option<Pat> as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [ParamOrTsParamProp] {
-    #[doc = "Calls [Visit`::visit_param_or_ts_param_props`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_param_or_ts_param_props(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ParamOrTsParamProp as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Param] {
-    #[doc = "Calls [Visit`::visit_params`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_params(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Param as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Pat] {
-    #[doc = "Calls [Visit`::visit_pats`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_pats(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Pat as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [PropOrSpread] {
-    #[doc = "Calls [Visit`::visit_prop_or_spreads`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_prop_or_spreads(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <PropOrSpread as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for swc_common::Span {
-    #[doc = "Calls [Visit`::visit_span`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_span(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Stmt] {
-    #[doc = "Calls [Visit`::visit_stmts`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_stmts(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Stmt as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [SwitchCase] {
-    #[doc = "Calls [Visit`::visit_switch_cases`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_switch_cases(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <SwitchCase as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for swc_common::SyntaxContext {
-    #[doc = "Calls [Visit`::visit_syntax_context`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_syntax_context(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [TplElement] {
-    #[doc = "Calls [Visit`::visit_tpl_elements`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_tpl_elements(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TplElement as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [TsEnumMember] {
-    #[doc = "Calls [Visit`::visit_ts_enum_members`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_enum_members(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsEnumMember as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [TsExprWithTypeArgs] {
-    #[doc = "Calls [Visit`::visit_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_expr_with_type_argss(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsExprWithTypeArgs as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [TsFnParam] {
-    #[doc = "Calls [Visit`::visit_ts_fn_params`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_fn_params(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsFnParam as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [TsTupleElement] {
-    #[doc = "Calls [Visit`::visit_ts_tuple_elements`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_tuple_elements(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsTupleElement as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [TsTypeElement] {
-    #[doc = "Calls [Visit`::visit_ts_type_elements`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_elements(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsTypeElement as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [TsTypeParam] {
-    #[doc = "Calls [Visit`::visit_ts_type_params`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_type_params(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsTypeParam as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [Box<TsType>] {
-    #[doc = "Calls [Visit`::visit_ts_types`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_ts_types(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Box<TsType> as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + Visit> VisitWith<V> for [VarDeclarator] {
-    #[doc = "Calls [Visit`::visit_var_declarators`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as Visit>::visit_var_declarators(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <VarDeclarator as VisitWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V, T> VisitWith<V> for std::boxed::Box<T>
-where
-    V: ?Sized + Visit,
-    T: VisitWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <T as VisitWith<V>>::visit_with(&**self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <T as VisitWith<V>>::visit_children_with(&**self, visitor);
-        v
-    }
-}
-impl<V, T> VisitWith<V> for std::vec::Vec<T>
-where
-    V: ?Sized + Visit,
-    [T]: VisitWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitWith<V>>::visit_with(self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitWith<V>>::visit_children_with(self, visitor);
-        v
-    }
-}
-#[doc = r" A visitor trait for traversing the AST."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitAstPath {
-    #[doc = "Visit a node of type `Accessibility`.\n\nBy default, this method calls \
-             [`Accessibility::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Accessibility,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Accessibility as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ArrayLit`.\n\nBy default, this method calls \
-             [`ArrayLit::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_array_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ArrayLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ArrayPat`.\n\nBy default, this method calls \
-             [`ArrayPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_array_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ArrayPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ArrowExpr`.\n\nBy default, this method calls \
-             [`ArrowExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_arrow_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrowExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ArrowExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AssignExpr`.\n\nBy default, this method calls \
-             [`AssignExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_assign_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AssignExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AssignOp`.\n\nBy default, this method calls \
-             [`AssignOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_assign_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AssignOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AssignPat`.\n\nBy default, this method calls \
-             [`AssignPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_assign_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AssignPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AssignPatProp`.\n\nBy default, this method calls \
-             [`AssignPatProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_assign_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AssignPatProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AssignProp`.\n\nBy default, this method calls \
-             [`AssignProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_assign_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AssignProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `AssignTarget`.\n\nBy default, this method calls \
-             [`AssignTarget::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AssignTarget as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AssignTargetPat`.\n\nBy default, this method calls \
-             [`AssignTargetPat::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_assign_target_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTargetPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AssignTargetPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <swc_atoms::Atom as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AutoAccessor`.\n\nBy default, this method calls \
-             [`AutoAccessor::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_auto_accessor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AutoAccessor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AutoAccessor as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `AwaitExpr`.\n\nBy default, this method calls \
-             [`AwaitExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_await_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AwaitExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <AwaitExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `BigInt`.\n\nBy default, this method calls \
-             [`BigInt::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_big_int<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigInt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BigInt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `BigIntValue`.\n\nBy default, this method calls \
-             [`BigIntValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_big_int_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigIntValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BigIntValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `BinExpr`.\n\nBy default, this method calls \
-             [`BinExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_bin_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BinExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `BinaryOp`.\n\nBy default, this method calls \
-             [`BinaryOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_binary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BinaryOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `BindingIdent`.\n\nBy default, this method calls \
-             [`BindingIdent::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_binding_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BindingIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BindingIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `BlockStmt`.\n\nBy default, this method calls \
-             [`BlockStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BlockStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `BlockStmtOrExpr`.\n\nBy default, this method calls \
-             [`BlockStmtOrExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmtOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BlockStmtOrExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Bool`.\n\nBy default, this method calls \
-             [`Bool::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
-        <Bool as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `BreakStmt`.\n\nBy default, this method calls \
-             [`BreakStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_break_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BreakStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <BreakStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `CallExpr`.\n\nBy default, this method calls \
-             [`CallExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_call_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CallExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CallExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Callee`.\n\nBy default, this method calls \
-             [`Callee::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
-        <Callee as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `CatchClause`.\n\nBy default, this method calls \
-             [`CatchClause::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CatchClause,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CatchClause as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Class`.\n\nBy default, this method calls \
-             [`Class::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
-        <Class as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ClassDecl`.\n\nBy default, this method calls \
-             [`ClassDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_class_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ClassDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ClassExpr`.\n\nBy default, this method calls \
-             [`ClassExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_class_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ClassExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ClassMember`.\n\nBy default, this method calls \
-             [`ClassMember::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_class_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ClassMember as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ClassMember >`.\n\nBy default, this method calls [`Vec < \
-             ClassMember >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_class_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ClassMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ClassMember] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ClassMethod`.\n\nBy default, this method calls \
-             [`ClassMethod::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_class_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ClassMethod as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ClassProp`.\n\nBy default, this method calls \
-             [`ClassProp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_class_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ClassProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ComputedPropName`.\n\nBy default, this method calls \
-             [`ComputedPropName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_computed_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComputedPropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ComputedPropName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `CondExpr`.\n\nBy default, this method calls \
-             [`CondExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_cond_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CondExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <CondExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Constructor`.\n\nBy default, this method calls \
-             [`Constructor::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_constructor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Constructor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Constructor as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ContinueStmt`.\n\nBy default, this method calls \
-             [`ContinueStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_continue_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContinueStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ContinueStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DebuggerStmt`.\n\nBy default, this method calls \
-             [`DebuggerStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_debugger_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DebuggerStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DebuggerStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Decl`.\n\nBy default, this method calls \
-             [`Decl::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
-        <Decl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Decorator`.\n\nBy default, this method calls \
-             [`Decorator::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_decorator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Decorator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Decorator as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < Decorator >`.\n\nBy default, this method calls [`Vec < \
-             Decorator >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_decorators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Decorator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[Decorator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DefaultDecl`.\n\nBy default, this method calls \
-             [`DefaultDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DefaultDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `DoWhileStmt`.\n\nBy default, this method calls \
-             [`DoWhileStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_do_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DoWhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <DoWhileStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `EmptyStmt`.\n\nBy default, this method calls \
-             [`EmptyStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_empty_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EmptyStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <EmptyStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `EsVersion`.\n\nBy default, this method calls \
-             [`EsVersion::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_es_version<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EsVersion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <EsVersion as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ExportAll`.\n\nBy default, this method calls \
-             [`ExportAll::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_export_all<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportAll,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportAll as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ExportDecl`.\n\nBy default, this method calls \
-             [`ExportDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ExportDefaultDecl`.\n\nBy default, this method calls \
-             [`ExportDefaultDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_export_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportDefaultDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ExportDefaultExpr`.\n\nBy default, this method calls \
-             [`ExportDefaultExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_export_default_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportDefaultExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ExportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ExportDefaultSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_export_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportDefaultSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ExportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamedSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_export_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportNamedSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ExportNamespaceSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamespaceSpecifier::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamespaceSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportNamespaceSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ExportSpecifier`.\n\nBy default, this method calls \
-             [`ExportSpecifier::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_export_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExportSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ExportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ExportSpecifier >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_export_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ExportSpecifier] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Expr`.\n\nBy default, this method calls \
-             [`Expr::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
-        <Expr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ExprOrSpread`.\n\nBy default, this method calls \
-             [`ExprOrSpread::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExprOrSpread as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ExprOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             ExprOrSpread >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExprOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ExprOrSpread] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ExprStmt`.\n\nBy default, this method calls \
-             [`ExprStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_expr_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ExprStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < Box < Expr > >`.\n\nBy default, this method calls [`Vec < \
-             Box < Expr > >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_exprs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<Expr>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[Box<Expr>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `FnDecl`.\n\nBy default, this method calls \
-             [`FnDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_fn_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <FnDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `FnExpr`.\n\nBy default, this method calls \
-             [`FnExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_fn_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <FnExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ForHead`.\n\nBy default, this method calls \
-             [`ForHead::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_for_head<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForHead,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForHead as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ForInStmt`.\n\nBy default, this method calls \
-             [`ForInStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_for_in_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForInStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForInStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ForOfStmt`.\n\nBy default, this method calls \
-             [`ForOfStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_for_of_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForOfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForOfStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ForStmt`.\n\nBy default, this method calls \
-             [`ForStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_for_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ForStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Function as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `GetterProp`.\n\nBy default, this method calls \
-             [`GetterProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_getter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <GetterProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        <Ident as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `IdentName`.\n\nBy default, this method calls \
-             [`IdentName::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ident_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdentName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <IdentName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `IfStmt`.\n\nBy default, this method calls \
-             [`IfStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_if_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <IfStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Import`.\n\nBy default, this method calls \
-             [`Import::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
-        <Import as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ImportDecl`.\n\nBy default, this method calls \
-             [`ImportDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_import_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ImportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ImportDefaultSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_import_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportDefaultSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ImportNamedSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_import_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportNamedSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportPhase`.\n\nBy default, this method calls \
-             [`ImportPhase::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_import_phase<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPhase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportPhase as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportSpecifier`.\n\nBy default, this method calls \
-             [`ImportSpecifier::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_import_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ImportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ImportSpecifier >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_import_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ImportSpecifier] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportStarAsSpecifier`.\n\nBy default, this method calls \
-             [`ImportStarAsSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportStarAsSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportStarAsSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ImportWith`.\n\nBy default, this method calls \
-             [`ImportWith::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_import_with<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWith,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportWith as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
-             [`ImportWithItem::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_import_with_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWithItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ImportWithItem as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ImportWithItem >`.\n\nBy default, this method calls [`Vec \
-             < ImportWithItem >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_import_with_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportWithItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ImportWithItem] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Invalid`.\n\nBy default, this method calls \
-             [`Invalid::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_invalid<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Invalid,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Invalid as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `JSXAttr`.\n\nBy default, this method calls \
-             [`JSXAttr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_jsx_attr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXAttr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `JSXAttrName`.\n\nBy default, this method calls \
-             [`JSXAttrName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_attr_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXAttrName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXAttrOrSpread`.\n\nBy default, this method calls \
-             [`JSXAttrOrSpread::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXAttrOrSpread as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < JSXAttrOrSpread >`.\n\nBy default, this method calls \
-             [`Vec < JSXAttrOrSpread >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXAttrOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[JSXAttrOrSpread] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXAttrValue`.\n\nBy default, this method calls \
-             [`JSXAttrValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXAttrValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXClosingElement`.\n\nBy default, this method calls \
-             [`JSXClosingElement::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXClosingElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXClosingFragment`.\n\nBy default, this method calls \
-             [`JSXClosingFragment::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXClosingFragment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXElement`.\n\nBy default, this method calls \
-             [`JSXElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `JSXElementChild`.\n\nBy default, this method calls \
-             [`JSXElementChild::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_jsx_element_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXElementChild as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < JSXElementChild >`.\n\nBy default, this method calls \
-             [`Vec < JSXElementChild >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_jsx_element_childs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXElementChild],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[JSXElementChild] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXElementName`.\n\nBy default, this method calls \
-             [`JSXElementName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_element_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXElementName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXEmptyExpr`.\n\nBy default, this method calls \
-             [`JSXEmptyExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXEmptyExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXEmptyExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXExpr`.\n\nBy default, this method calls \
-             [`JSXExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_jsx_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
-             [`JSXExprContainer::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_jsx_expr_container<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExprContainer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXExprContainer as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXFragment`.\n\nBy default, this method calls \
-             [`JSXFragment::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXFragment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXMemberExpr`.\n\nBy default, this method calls \
-             [`JSXMemberExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXMemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXMemberExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXNamespacedName`.\n\nBy default, this method calls \
-             [`JSXNamespacedName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXNamespacedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXNamespacedName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXObject`.\n\nBy default, this method calls \
-             [`JSXObject::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_jsx_object<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXObject,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXObject as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `JSXOpeningElement`.\n\nBy default, this method calls \
-             [`JSXOpeningElement::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_jsx_opening_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXOpeningElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXOpeningFragment`.\n\nBy default, this method calls \
-             [`JSXOpeningFragment::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXOpeningFragment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXSpreadChild`.\n\nBy default, this method calls \
-             [`JSXSpreadChild::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_jsx_spread_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXSpreadChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXSpreadChild as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `JSXText`.\n\nBy default, this method calls \
-             [`JSXText::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_jsx_text<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXText,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <JSXText as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Key`.\n\nBy default, this method calls \
-             [`Key::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
-        <Key as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `KeyValuePatProp`.\n\nBy default, this method calls \
-             [`KeyValuePatProp::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValuePatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <KeyValuePatProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `KeyValueProp`.\n\nBy default, this method calls \
-             [`KeyValueProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_key_value_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValueProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <KeyValueProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `LabeledStmt`.\n\nBy default, this method calls \
-             [`LabeledStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_labeled_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LabeledStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <LabeledStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Lit`.\n\nBy default, this method calls \
-             [`Lit::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
-        <Lit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MemberExpr`.\n\nBy default, this method calls \
-             [`MemberExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MemberExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MemberProp`.\n\nBy default, this method calls \
-             [`MemberProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_member_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MemberProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MetaPropExpr`.\n\nBy default, this method calls \
-             [`MetaPropExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_meta_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MetaPropExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MetaPropKind`.\n\nBy default, this method calls \
-             [`MetaPropKind::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_meta_prop_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MetaPropKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `MethodKind`.\n\nBy default, this method calls \
-             [`MethodKind::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_method_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MethodKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `MethodProp`.\n\nBy default, this method calls \
-             [`MethodProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_method_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <MethodProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Module`.\n\nBy default, this method calls \
-             [`Module::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
-        <Module as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ModuleDecl`.\n\nBy default, this method calls \
-             [`ModuleDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ModuleDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ModuleExportName`.\n\nBy default, this method calls \
-             [`ModuleExportName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleExportName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ModuleExportName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `ModuleItem`.\n\nBy default, this method calls \
-             [`ModuleItem::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_module_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ModuleItem as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < ModuleItem >`.\n\nBy default, this method calls [`Vec < \
-             ModuleItem >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_module_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ModuleItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ModuleItem] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `NamedExport`.\n\nBy default, this method calls \
-             [`NamedExport::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_named_export<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedExport,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NamedExport as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `NewExpr`.\n\nBy default, this method calls \
-             [`NewExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_new_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NewExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <NewExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Null`.\n\nBy default, this method calls \
-             [`Null::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
-        <Null as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        <Number as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ObjectLit`.\n\nBy default, this method calls \
-             [`ObjectLit::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ObjectLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ObjectPat`.\n\nBy default, this method calls \
-             [`ObjectPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_object_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ObjectPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ObjectPatProp`.\n\nBy default, this method calls \
-             [`ObjectPatProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_object_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ObjectPatProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ObjectPatProp >`.\n\nBy default, this method calls [`Vec \
-             < ObjectPatProp >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_object_pat_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ObjectPatProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ObjectPatProp] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Accessibility >`.\n\nBy default, this method calls \
-             [`Option < Accessibility >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Accessibility>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Accessibility> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<swc_atoms::Atom> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < BlockStmt >`.\n\nBy default, this method calls \
-             [`Option < BlockStmt >::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_opt_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<BlockStmt>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<BlockStmt> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `OptCall`.\n\nBy default, this method calls \
-             [`OptCall::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_opt_call<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptCall,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <OptCall as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
-             [`Option < CatchClause >::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_opt_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<CatchClause>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<CatchClause> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `OptChainBase`.\n\nBy default, this method calls \
-             [`OptChainBase::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_opt_chain_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <OptChainBase as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `OptChainExpr`.\n\nBy default, this method calls \
-             [`OptChainExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_opt_chain_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <OptChainExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < Expr > >`.\n\nBy default, this method calls \
-             [`Option < Box < Expr > >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Expr>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<Expr>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < ExprOrSpread >`.\n\nBy default, this method calls \
-             [`Option < ExprOrSpread >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ExprOrSpread>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<ExprOrSpread> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Vec < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Option < Vec < ExprOrSpread > >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Vec<ExprOrSpread>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Ident> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
-             [`Option < JSXAttrValue >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXAttrValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<JSXAttrValue> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < JSXClosingElement >`.\n\nBy default, this method calls \
-             [`Option < JSXClosingElement >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXClosingElement>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<JSXClosingElement> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < ModuleExportName >`.\n\nBy default, this method calls \
-             [`Option < ModuleExportName >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ModuleExportName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<ModuleExportName> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < ObjectLit > >`.\n\nBy default, this method calls \
-             [`Option < Box < ObjectLit > >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ObjectLit>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<ObjectLit>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Pat >`.\n\nBy default, this method calls [`Option < \
-             Pat >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_opt_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Pat>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Pat> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < swc_common :: Span >`.\n\nBy default, this method \
-             calls [`Option < swc_common :: Span >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_common::Span>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<swc_common::Span> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < Stmt > >`.\n\nBy default, this method calls \
-             [`Option < Box < Stmt > >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Stmt>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<Stmt>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < Str > >`.\n\nBy default, this method calls \
-             [`Option < Box < Str > >::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_opt_str<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Str>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<Str>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < TruePlusMinus >`.\n\nBy default, this method calls \
-             [`Option < TruePlusMinus >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TruePlusMinus>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<TruePlusMinus> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < TsEntityName >`.\n\nBy default, this method calls \
-             [`Option < TsEntityName >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsEntityName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<TsEntityName> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < TsNamespaceBody >`.\n\nBy default, this method calls \
-             [`Option < TsNamespaceBody >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsNamespaceBody>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<TsNamespaceBody> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < TsType > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsType > >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<TsType>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < TsTypeAnn > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsTypeAnn > >::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<TsTypeAnn>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < TsTypeParamDecl > >`.\n\nBy default, this method \
-             calls [`Option < Box < TsTypeParamDecl > >::visit_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Option < Box < TsTypeParamInstantiation > >`.\n\nBy default, \
-             this method calls [`Option < Box < TsTypeParamInstantiation > \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < Self > > :: visit_children_with_ast_path (node , self , __ast_path)
-    }
-    #[doc = "Visit a node of type `Option < VarDeclOrExpr >`.\n\nBy default, this method calls \
-             [`Option < VarDeclOrExpr >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<VarDeclOrExpr>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Option<VarDeclOrExpr> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < Option < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Vec < Option < ExprOrSpread > >::visit_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
-    #[inline]
-    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<ExprOrSpread>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[Option<ExprOrSpread>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < Option < Pat > >`.\n\nBy default, this method calls [`Vec \
-             < Option < Pat > >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_opt_vec_pats<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<Pat>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[Option<Pat>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Param`.\n\nBy default, this method calls \
-             [`Param::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
-        <Param as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ParamOrTsParamProp`.\n\nBy default, this method calls \
-             [`ParamOrTsParamProp::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParamOrTsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ParamOrTsParamProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < ParamOrTsParamProp >`.\n\nBy default, this method calls \
-             [`Vec < ParamOrTsParamProp >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ParamOrTsParamProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[ParamOrTsParamProp] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < Param >`.\n\nBy default, this method calls [`Vec < Param \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Param],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[Param] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ParenExpr`.\n\nBy default, this method calls \
-             [`ParenExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_paren_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParenExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ParenExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Pat`.\n\nBy default, this method calls \
-             [`Pat::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
-        <Pat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < Pat >`.\n\nBy default, this method calls [`Vec < Pat \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
-        <[Pat] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `PrivateMethod`.\n\nBy default, this method calls \
-             [`PrivateMethod::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_private_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PrivateMethod as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PrivateName`.\n\nBy default, this method calls \
-             [`PrivateName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_private_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PrivateName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `PrivateProp`.\n\nBy default, this method calls \
-             [`PrivateProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_private_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PrivateProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Program`.\n\nBy default, this method calls \
-             [`Program::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_program<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Program,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <Program as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Prop`.\n\nBy default, this method calls \
-             [`Prop::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
-        <Prop as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `PropName`.\n\nBy default, this method calls \
-             [`PropName::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PropName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `PropOrSpread`.\n\nBy default, this method calls \
-             [`PropOrSpread::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_prop_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <PropOrSpread as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             PropOrSpread >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_prop_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PropOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[PropOrSpread] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
-             [`Regex::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
-        <Regex as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `RestPat`.\n\nBy default, this method calls \
-             [`RestPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_rest_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RestPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <RestPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ReturnStmt`.\n\nBy default, this method calls \
-             [`ReturnStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_return_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ReturnStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ReturnStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Script`.\n\nBy default, this method calls \
-             [`Script::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
-        <Script as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `SeqExpr`.\n\nBy default, this method calls \
-             [`SeqExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_seq_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SeqExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SeqExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `SetterProp`.\n\nBy default, this method calls \
-             [`SetterProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_setter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SetterProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `SimpleAssignTarget`.\n\nBy default, this method calls \
-             [`SimpleAssignTarget::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_simple_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleAssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SimpleAssignTarget as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <swc_common::Span as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SpreadElement`.\n\nBy default, this method calls \
-             [`SpreadElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_spread_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SpreadElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SpreadElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `StaticBlock`.\n\nBy default, this method calls \
-             [`StaticBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_static_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StaticBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <StaticBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Stmt`.\n\nBy default, this method calls \
-             [`Stmt::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
-        <Stmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < Stmt >`.\n\nBy default, this method calls [`Vec < Stmt \
-             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
-        <[Stmt] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        <Str as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Super`.\n\nBy default, this method calls \
-             [`Super::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
-        <Super as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `SuperProp`.\n\nBy default, this method calls \
-             [`SuperProp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_super_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SuperProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `SuperPropExpr`.\n\nBy default, this method calls \
-             [`SuperPropExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_super_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SuperPropExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SwitchCase`.\n\nBy default, this method calls \
-             [`SwitchCase::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_switch_case<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchCase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SwitchCase as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < SwitchCase >`.\n\nBy default, this method calls [`Vec < \
-             SwitchCase >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_switch_cases<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SwitchCase],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[SwitchCase] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `SwitchStmt`.\n\nBy default, this method calls \
-             [`SwitchStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_switch_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <SwitchStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `swc_common :: SyntaxContext`.\n\nBy default, this method calls \
-             [`swc_common :: SyntaxContext::visit_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_syntax_context<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::SyntaxContext,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <swc_common::SyntaxContext as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TaggedTpl`.\n\nBy default, this method calls \
-             [`TaggedTpl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_tagged_tpl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TaggedTpl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TaggedTpl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ThisExpr`.\n\nBy default, this method calls \
-             [`ThisExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_this_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThisExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ThisExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ThrowStmt`.\n\nBy default, this method calls \
-             [`ThrowStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_throw_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThrowStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <ThrowStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Tpl`.\n\nBy default, this method calls \
-             [`Tpl::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
-        <Tpl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TplElement`.\n\nBy default, this method calls \
-             [`TplElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_tpl_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TplElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TplElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < TplElement >`.\n\nBy default, this method calls [`Vec < \
-             TplElement >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_tpl_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TplElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[TplElement] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TruePlusMinus`.\n\nBy default, this method calls \
-             [`TruePlusMinus::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TruePlusMinus,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TruePlusMinus as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TryStmt`.\n\nBy default, this method calls \
-             [`TryStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_try_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TryStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TryStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsArrayType`.\n\nBy default, this method calls \
-             [`TsArrayType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_array_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsArrayType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsArrayType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsAsExpr`.\n\nBy default, this method calls \
-             [`TsAsExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_as_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsAsExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsAsExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsCallSignatureDecl`.\n\nBy default, this method calls \
-             [`TsCallSignatureDecl::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsCallSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsCallSignatureDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsConditionalType`.\n\nBy default, this method calls \
-             [`TsConditionalType::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_conditional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConditionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsConditionalType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsConstAssertion`.\n\nBy default, this method calls \
-             [`TsConstAssertion::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_const_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsConstAssertion as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsConstructSignatureDecl`.\n\nBy default, this method calls \
-             [`TsConstructSignatureDecl::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsConstructSignatureDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsConstructorType`.\n\nBy default, this method calls \
-             [`TsConstructorType::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsConstructorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsEntityName`.\n\nBy default, this method calls \
-             [`TsEntityName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEntityName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsEntityName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsEnumDecl`.\n\nBy default, this method calls \
-             [`TsEnumDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_enum_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsEnumDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsEnumMember`.\n\nBy default, this method calls \
-             [`TsEnumMember::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_enum_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsEnumMember as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsEnumMemberId`.\n\nBy default, this method calls \
-             [`TsEnumMemberId::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMemberId,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsEnumMemberId as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < TsEnumMember >`.\n\nBy default, this method calls [`Vec < \
-             TsEnumMember >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_enum_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsEnumMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[TsEnumMember] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsExportAssignment`.\n\nBy default, this method calls \
-             [`TsExportAssignment::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_export_assignment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExportAssignment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsExportAssignment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsExprWithTypeArgs`.\n\nBy default, this method calls \
-             [`TsExprWithTypeArgs::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExprWithTypeArgs,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsExprWithTypeArgs as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < TsExprWithTypeArgs >`.\n\nBy default, this method calls \
-             [`Vec < TsExprWithTypeArgs >::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsExprWithTypeArgs],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[TsExprWithTypeArgs] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsExternalModuleRef`.\n\nBy default, this method calls \
-             [`TsExternalModuleRef::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExternalModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsExternalModuleRef as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsFnOrConstructorType`.\n\nBy default, this method calls \
-             [`TsFnOrConstructorType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnOrConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsFnOrConstructorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsFnParam`.\n\nBy default, this method calls \
-             [`TsFnParam::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_fn_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsFnParam as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < TsFnParam >`.\n\nBy default, this method calls [`Vec < \
-             TsFnParam >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_fn_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsFnParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[TsFnParam] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsFnType`.\n\nBy default, this method calls \
-             [`TsFnType::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_fn_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsFnType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsGetterSignature`.\n\nBy default, this method calls \
-             [`TsGetterSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_getter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsGetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsGetterSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsImportEqualsDecl`.\n\nBy default, this method calls \
-             [`TsImportEqualsDecl::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportEqualsDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsImportEqualsDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsImportType`.\n\nBy default, this method calls \
-             [`TsImportType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_import_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsImportType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsIndexSignature`.\n\nBy default, this method calls \
-             [`TsIndexSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_index_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsIndexSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsIndexedAccessType`.\n\nBy default, this method calls \
-             [`TsIndexedAccessType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexedAccessType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsIndexedAccessType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsInferType`.\n\nBy default, this method calls \
-             [`TsInferType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_infer_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInferType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsInferType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsInstantiation`.\n\nBy default, this method calls \
-             [`TsInstantiation::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsInstantiation as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsInterfaceBody`.\n\nBy default, this method calls \
-             [`TsInterfaceBody::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_interface_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsInterfaceBody as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsInterfaceDecl`.\n\nBy default, this method calls \
-             [`TsInterfaceDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_interface_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsInterfaceDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsIntersectionType`.\n\nBy default, this method calls \
-             [`TsIntersectionType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsIntersectionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsKeywordType`.\n\nBy default, this method calls \
-             [`TsKeywordType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_keyword_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsKeywordType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsKeywordTypeKind`.\n\nBy default, this method calls \
-             [`TsKeywordTypeKind::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordTypeKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsKeywordTypeKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsLit`.\n\nBy default, this method calls \
-             [`TsLit::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
-        <TsLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsLitType`.\n\nBy default, this method calls \
-             [`TsLitType::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsLitType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsMappedType`.\n\nBy default, this method calls \
-             [`TsMappedType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_mapped_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMappedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsMappedType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsMethodSignature`.\n\nBy default, this method calls \
-             [`TsMethodSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_method_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMethodSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsMethodSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsModuleBlock`.\n\nBy default, this method calls \
-             [`TsModuleBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_module_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsModuleBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsModuleDecl`.\n\nBy default, this method calls \
-             [`TsModuleDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsModuleDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsModuleName`.\n\nBy default, this method calls \
-             [`TsModuleName::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_module_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsModuleName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsModuleRef`.\n\nBy default, this method calls \
-             [`TsModuleRef::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsModuleRef as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsNamespaceBody`.\n\nBy default, this method calls \
-             [`TsNamespaceBody::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsNamespaceBody as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsNamespaceDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsNamespaceDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsNamespaceExportDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceExportDecl::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsNamespaceExportDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsNonNullExpr`.\n\nBy default, this method calls \
-             [`TsNonNullExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNonNullExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsNonNullExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsOptionalType`.\n\nBy default, this method calls \
-             [`TsOptionalType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_optional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsOptionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsOptionalType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsParamProp`.\n\nBy default, this method calls \
-             [`TsParamProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsParamProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsParamPropParam`.\n\nBy default, this method calls \
-             [`TsParamPropParam::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamPropParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsParamPropParam as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsParenthesizedType`.\n\nBy default, this method calls \
-             [`TsParenthesizedType::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParenthesizedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsParenthesizedType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsPropertySignature`.\n\nBy default, this method calls \
-             [`TsPropertySignature::visit_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
-    #[inline]
-    fn visit_ts_property_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsPropertySignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsPropertySignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsQualifiedName`.\n\nBy default, this method calls \
-             [`TsQualifiedName::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_qualified_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsQualifiedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsQualifiedName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsRestType`.\n\nBy default, this method calls \
-             [`TsRestType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_rest_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsRestType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsRestType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsSatisfiesExpr`.\n\nBy default, this method calls \
-             [`TsSatisfiesExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSatisfiesExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsSatisfiesExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsSetterSignature`.\n\nBy default, this method calls \
-             [`TsSetterSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_setter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsSetterSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsThisType`.\n\nBy default, this method calls \
-             [`TsThisType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_this_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsThisType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsThisTypeOrIdent`.\n\nBy default, this method calls \
-             [`TsThisTypeOrIdent::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisTypeOrIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsThisTypeOrIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTplLitType`.\n\nBy default, this method calls \
-             [`TsTplLitType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTplLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTplLitType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTupleElement`.\n\nBy default, this method calls \
-             [`TsTupleElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_tuple_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTupleElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < TsTupleElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTupleElement >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTupleElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[TsTupleElement] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTupleType`.\n\nBy default, this method calls \
-             [`TsTupleType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_tuple_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTupleType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsType`.\n\nBy default, this method calls \
-             [`TsType::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
-    #[inline]
-    fn visit_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsTypeAliasDecl`.\n\nBy default, this method calls \
-             [`TsTypeAliasDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAliasDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeAliasDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeAnn`.\n\nBy default, this method calls \
-             [`TsTypeAnn::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAnn,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeAnn as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsTypeAssertion`.\n\nBy default, this method calls \
-             [`TsTypeAssertion::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_type_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeAssertion as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeElement`.\n\nBy default, this method calls \
-             [`TsTypeElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_type_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < TsTypeElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTypeElement >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_type_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[TsTypeElement] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeLit`.\n\nBy default, this method calls \
-             [`TsTypeLit::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_type_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `TsTypeOperator`.\n\nBy default, this method calls \
-             [`TsTypeOperator::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_type_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeOperatorOp`.\n\nBy default, this method calls \
-             [`TsTypeOperatorOp::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperatorOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeOperatorOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeParam`.\n\nBy default, this method calls \
-             [`TsTypeParam::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_type_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeParam as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeParamDecl`.\n\nBy default, this method calls \
-             [`TsTypeParamDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeParamDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeParamInstantiation`.\n\nBy default, this method calls \
-             [`TsTypeParamInstantiation::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeParamInstantiation as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < TsTypeParam >`.\n\nBy default, this method calls [`Vec < \
-             TsTypeParam >::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_type_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[TsTypeParam] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypePredicate`.\n\nBy default, this method calls \
-             [`TsTypePredicate::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_type_predicate<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypePredicate,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypePredicate as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeQuery`.\n\nBy default, this method calls \
-             [`TsTypeQuery::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_type_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeQueryExpr`.\n\nBy default, this method calls \
-             [`TsTypeQueryExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQueryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeQueryExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsTypeRef`.\n\nBy default, this method calls \
-             [`TsTypeRef::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_ts_type_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsTypeRef as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < Box < TsType > >`.\n\nBy default, this method calls [`Vec \
-             < Box < TsType > >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_ts_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<TsType>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[Box<TsType>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsUnionOrIntersectionType`.\n\nBy default, this method calls \
-             [`TsUnionOrIntersectionType::visit_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
-    #[inline]
-    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionOrIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsUnionOrIntersectionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `TsUnionType`.\n\nBy default, this method calls \
-             [`TsUnionType::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_ts_union_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <TsUnionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `UnaryExpr`.\n\nBy default, this method calls \
-             [`UnaryExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_unary_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UnaryExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `UnaryOp`.\n\nBy default, this method calls \
-             [`UnaryOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_unary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UnaryOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `UpdateExpr`.\n\nBy default, this method calls \
-             [`UpdateExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_update_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UpdateExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `UpdateOp`.\n\nBy default, this method calls \
-             [`UpdateOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_update_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UpdateOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `UsingDecl`.\n\nBy default, this method calls \
-             [`UsingDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_using_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UsingDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <UsingDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `VarDecl`.\n\nBy default, this method calls \
-             [`VarDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_var_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <VarDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `VarDeclKind`.\n\nBy default, this method calls \
-             [`VarDeclKind::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_var_decl_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <VarDeclKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `VarDeclOrExpr`.\n\nBy default, this method calls \
-             [`VarDeclOrExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <VarDeclOrExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `VarDeclarator`.\n\nBy default, this method calls \
-             [`VarDeclarator::visit_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn visit_var_declarator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclarator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <VarDeclarator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `Vec < VarDeclarator >`.\n\nBy default, this method calls [`Vec \
-             < VarDeclarator >::visit_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
-    #[inline]
-    fn visit_var_declarators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [VarDeclarator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <[VarDeclarator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
-            node, self, __ast_path,
-        )
-    }
-    #[doc = "Visit a node of type `WhileStmt`.\n\nBy default, this method calls \
-             [`WhileStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <WhileStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `WithStmt`.\n\nBy default, this method calls \
-             [`WithStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_with_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WithStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <WithStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `YieldExpr`.\n\nBy default, this method calls \
-             [`YieldExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn visit_yield_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast YieldExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <YieldExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for &mut V
-where
-    V: ?Sized + VisitAstPath,
-{
-    #[inline]
-    fn visit_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Accessibility,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_accessibility(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_array_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_array_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_array_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_array_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_arrow_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrowExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_arrow_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_pat_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_target(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_target_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTargetPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_target_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_auto_accessor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AutoAccessor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_auto_accessor(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_await_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AwaitExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_await_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_big_int<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigInt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_big_int(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_big_int_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigIntValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_big_int_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_bin_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_bin_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_binary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_binary_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_binding_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BindingIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_binding_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_block_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmtOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_block_stmt_or_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_bool(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_break_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BreakStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_break_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_call_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CallExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_call_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_callee(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CatchClause,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_catch_clause(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_class(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_member(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ClassMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_members(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_method(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_computed_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComputedPropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_computed_prop_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_cond_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CondExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_cond_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_constructor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Constructor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_constructor(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_continue_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContinueStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_continue_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_debugger_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DebuggerStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_debugger_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_decorator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Decorator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_decorator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_decorators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Decorator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_decorators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_default_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_do_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DoWhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_do_while_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_empty_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EmptyStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_empty_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_es_version<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EsVersion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_es_version(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_all<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportAll,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_all(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_default_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_named_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamespaceSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_namespace_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_specifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExprOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_exprs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<Expr>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_exprs(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_fn_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_fn_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_fn_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_fn_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_head<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForHead,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_head(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_in_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForInStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_in_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_of_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForOfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_of_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_getter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_getter_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ident_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdentName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ident_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_if_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_if_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_import(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_default_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_named_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_phase<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPhase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_phase(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_specifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportStarAsSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_star_as_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_with<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWith,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_with_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWithItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with_item(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_with_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportWithItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with_items(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_invalid<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Invalid,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_invalid(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXAttrOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_closing_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_closing_fragment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_child(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element_childs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXElementChild],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_childs(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXEmptyExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_empty_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_expr_container<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExprContainer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_expr_container(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_fragment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXMemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_member_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXNamespacedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_namespaced_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_object<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXObject,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_object(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_opening_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_opening_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_opening_fragment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_spread_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXSpreadChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_spread_child(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_text<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXText,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_text(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_key(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValuePatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_key_value_pat_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_key_value_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValueProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_key_value_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_labeled_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LabeledStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_labeled_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_member_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_member_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_member_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_meta_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_meta_prop_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_meta_prop_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_meta_prop_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_method_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_method_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_method_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_method_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_module(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleExportName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_export_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_item(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ModuleItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_items(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_named_export<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedExport,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_named_export(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_new_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NewExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_new_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_null(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_pat_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ObjectPatProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat_props(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Accessibility>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_accessibility(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<BlockStmt>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_block_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_call<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptCall,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_call(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<CatchClause>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_catch_clause(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_chain_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_chain_base(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_chain_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_chain_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Expr>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ExprOrSpread>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXAttrValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_jsx_attr_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXClosingElement>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_jsx_closing_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ModuleExportName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_module_export_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ObjectLit>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_object_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Pat>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_common::Span>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Stmt>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_str<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Str>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_str(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TruePlusMinus>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_true_plus_minus(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsEntityName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_entity_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsNamespaceBody>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_namespace_body(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_ann(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_param_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<VarDeclOrExpr>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_var_decl_or_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<ExprOrSpread>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_vec_pats<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<Pat>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_vec_pats(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParamOrTsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_param_or_ts_param_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ParamOrTsParamProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_param_or_ts_param_props(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Param],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_params(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_paren_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParenExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_paren_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_pats(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_private_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_method(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_private_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_private_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_program<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Program,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_program(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PropOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_regex(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_rest_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RestPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_rest_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_return_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ReturnStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_return_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_script(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_seq_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SeqExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_seq_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_setter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_setter_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_simple_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleAssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_simple_assign_target(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_spread_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SpreadElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_spread_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_static_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StaticBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_static_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_stmts(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_super(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_super_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_super_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_super_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_super_prop_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_switch_case<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchCase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_case(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_switch_cases<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SwitchCase],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_cases(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_switch_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_syntax_context<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::SyntaxContext,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_syntax_context(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tagged_tpl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TaggedTpl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tagged_tpl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_this_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThisExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_this_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_throw_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThrowStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_throw_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_tpl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tpl_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TplElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tpl_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tpl_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TplElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tpl_elements(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TruePlusMinus,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_true_plus_minus(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_try_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TryStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_try_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_array_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsArrayType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_array_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_as_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsAsExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_as_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsCallSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_call_signature_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_conditional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConditionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_conditional_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_const_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_const_assertion(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_construct_signature_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_constructor_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEntityName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_entity_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_member(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMemberId,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_member_id(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsEnumMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_members(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_export_assignment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExportAssignment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_export_assignment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExprWithTypeArgs,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_expr_with_type_args(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsExprWithTypeArgs],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_expr_with_type_argss(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExternalModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_external_module_ref(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnOrConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsFnParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_params(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_getter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsGetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_getter_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportEqualsDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_import_equals_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_import_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_import_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_index_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_index_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexedAccessType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_indexed_access_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_infer_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInferType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_infer_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_instantiation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_interface_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_interface_body(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_interface_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_interface_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_intersection_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_keyword_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordTypeKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_keyword_type_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ts_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_lit_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_mapped_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMappedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_mapped_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_method_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMethodSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_method_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_ref(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_body(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_export_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNonNullExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_non_null_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_optional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsOptionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_optional_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_param_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamPropParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_param_prop_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParenthesizedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_parenthesized_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_property_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsPropertySignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_property_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_qualified_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsQualifiedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_qualified_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_rest_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsRestType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_rest_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSatisfiesExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_satisfies_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_setter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_setter_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_this_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_this_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisTypeOrIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_this_type_or_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTplLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tpl_lit_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tuple_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTupleElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_elements(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tuple_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAliasDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_alias_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAnn,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_ann(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_assertion(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_elements(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperatorOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_operator_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param_instantiation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_params(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_predicate<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypePredicate,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_predicate(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQueryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_query_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_ref(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<TsType>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionOrIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_union_or_intersection_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_union_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_union_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unary_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unary_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unary_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_update_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_update_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_update_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_update_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_using_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UsingDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_using_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_decl_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl_or_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_declarator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclarator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_declarator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_declarators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [VarDeclarator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_declarators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_while_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_with_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WithStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_with_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_yield_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast YieldExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_yield_expr(&mut **self, node, __ast_path)
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for Box<V>
-where
-    V: ?Sized + VisitAstPath,
-{
-    #[inline]
-    fn visit_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Accessibility,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_accessibility(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_array_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_array_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_array_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_array_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_arrow_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrowExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_arrow_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_pat_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_target(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_assign_target_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTargetPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_target_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_auto_accessor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AutoAccessor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_auto_accessor(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_await_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AwaitExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_await_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_big_int<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigInt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_big_int(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_big_int_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigIntValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_big_int_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_bin_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_bin_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_binary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_binary_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_binding_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BindingIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_binding_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_block_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmtOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_block_stmt_or_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_bool(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_break_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BreakStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_break_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_call_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CallExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_call_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_callee(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CatchClause,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_catch_clause(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_class(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_member(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ClassMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_members(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_method(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_class_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_computed_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComputedPropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_computed_prop_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_cond_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CondExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_cond_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_constructor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Constructor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_constructor(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_continue_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContinueStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_continue_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_debugger_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DebuggerStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_debugger_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_decorator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Decorator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_decorator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_decorators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Decorator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_decorators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_default_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_do_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DoWhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_do_while_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_empty_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EmptyStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_empty_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_es_version<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EsVersion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_es_version(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_all<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportAll,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_all(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_default_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_named_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamespaceSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_namespace_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_export_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_specifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExprOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_expr_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_exprs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<Expr>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_exprs(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_fn_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_fn_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_fn_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_fn_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_head<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForHead,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_head(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_in_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForInStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_in_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_of_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForOfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_of_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_for_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_getter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_getter_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ident_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdentName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ident_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_if_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_if_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_import(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_default_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_named_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_phase<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPhase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_phase(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_specifiers(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportStarAsSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_star_as_specifier(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_with<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWith,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_with_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWithItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with_item(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_import_with_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportWithItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with_items(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_invalid<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Invalid,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_invalid(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXAttrOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_closing_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_closing_fragment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_child(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element_childs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXElementChild],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_childs(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_element_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXEmptyExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_empty_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_expr_container<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExprContainer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_expr_container(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_fragment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXMemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_member_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXNamespacedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_namespaced_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_object<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXObject,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_object(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_opening_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_opening_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_opening_fragment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_spread_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXSpreadChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_spread_child(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_jsx_text<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXText,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_text(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_key(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValuePatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_key_value_pat_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_key_value_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValueProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_key_value_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_labeled_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LabeledStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_labeled_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_member_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_member_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_member_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_meta_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_meta_prop_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_meta_prop_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_meta_prop_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_method_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_method_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_method_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_method_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_module(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleExportName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_export_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_item(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_module_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ModuleItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_items(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_named_export<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedExport,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_named_export(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_new_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NewExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_new_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_null(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_object_pat_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ObjectPatProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat_props(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Accessibility>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_accessibility(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<BlockStmt>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_block_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_call<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptCall,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_call(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<CatchClause>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_catch_clause(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_chain_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_chain_base(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_chain_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_chain_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Expr>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ExprOrSpread>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXAttrValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_jsx_attr_value(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXClosingElement>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_jsx_closing_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ModuleExportName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_module_export_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ObjectLit>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_object_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Pat>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_common::Span>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Stmt>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_str<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Str>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_str(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TruePlusMinus>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_true_plus_minus(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsEntityName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_entity_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsNamespaceBody>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_namespace_body(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_ann(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_param_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<VarDeclOrExpr>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_var_decl_or_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<ExprOrSpread>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_opt_vec_pats<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<Pat>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_vec_pats(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParamOrTsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_param_or_ts_param_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ParamOrTsParamProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_param_or_ts_param_props(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Param],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_params(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_paren_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParenExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_paren_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_pats(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_private_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_method(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_private_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_private_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_program<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Program,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_program(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_or_spread(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_prop_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PropOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_or_spreads(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_regex(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_rest_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RestPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_rest_pat(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_return_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ReturnStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_return_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_script(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_seq_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SeqExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_seq_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_setter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_setter_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_simple_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleAssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_simple_assign_target(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_spread_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SpreadElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_spread_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_static_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StaticBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_static_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_stmts(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_super(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_super_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_super_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_super_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_super_prop_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_switch_case<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchCase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_case(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_switch_cases<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SwitchCase],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_cases(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_switch_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_syntax_context<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::SyntaxContext,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_syntax_context(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tagged_tpl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TaggedTpl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tagged_tpl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_this_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThisExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_this_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_throw_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThrowStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_throw_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_tpl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tpl_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TplElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tpl_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_tpl_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TplElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tpl_elements(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TruePlusMinus,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_true_plus_minus(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_try_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TryStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_try_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_array_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsArrayType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_array_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_as_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsAsExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_as_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsCallSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_call_signature_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_conditional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConditionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_conditional_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_const_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_const_assertion(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_construct_signature_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_constructor_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEntityName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_entity_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_member(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMemberId,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_member_id(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_enum_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsEnumMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_members(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_export_assignment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExportAssignment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_export_assignment(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExprWithTypeArgs,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_expr_with_type_args(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsExprWithTypeArgs],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_expr_with_type_argss(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExternalModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_external_module_ref(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnOrConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsFnParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_params(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_fn_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_getter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsGetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_getter_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportEqualsDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_import_equals_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_import_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_import_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_index_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_index_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexedAccessType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_indexed_access_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_infer_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInferType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_infer_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_instantiation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_interface_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_interface_body(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_interface_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_interface_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_intersection_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_keyword_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordTypeKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_keyword_type_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
-        <V as VisitAstPath>::visit_ts_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_lit_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_mapped_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMappedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_mapped_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_method_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMethodSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_method_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_block(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_ref(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_body(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_export_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNonNullExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_non_null_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_optional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsOptionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_optional_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_param_prop(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamPropParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_param_prop_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParenthesizedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_parenthesized_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_property_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsPropertySignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_property_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_qualified_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsQualifiedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_qualified_name(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_rest_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsRestType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_rest_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSatisfiesExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_satisfies_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_setter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_setter_signature(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_this_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_this_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisTypeOrIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_this_type_or_ident(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTplLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tpl_lit_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tuple_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTupleElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_elements(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_tuple_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAliasDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_alias_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAnn,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_ann(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_assertion(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_element(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_elements(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_operator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperatorOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_operator_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param_instantiation(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_params(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_predicate<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypePredicate,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_predicate(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_query(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQueryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_query_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_type_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_ref(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<TsType>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_types(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionOrIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_union_or_intersection_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_ts_union_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_union_type(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unary_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unary_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_unary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unary_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_update_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_update_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_update_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_update_op(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_using_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UsingDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_using_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_decl_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl_kind(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl_or_expr(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_declarator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclarator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_declarator(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_var_declarators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [VarDeclarator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_declarators(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_while_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_with_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WithStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_with_stmt(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_yield_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast YieldExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_yield_expr(&mut **self, node, __ast_path)
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<A, B> VisitAstPath for ::swc_visit::Either<A, B>
-where
-    A: VisitAstPath,
-    B: VisitAstPath,
-{
-    #[inline]
-    fn visit_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Accessibility,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_accessibility(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_accessibility(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_array_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_array_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_array_lit(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_array_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_array_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_array_pat(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_arrow_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrowExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_arrow_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_arrow_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_assign_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_assign_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_assign_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_assign_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_assign_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_assign_op(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_assign_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_assign_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_assign_pat(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_assign_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_assign_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_assign_pat_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_assign_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_assign_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_assign_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_assign_target(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_assign_target(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_assign_target_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTargetPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_assign_target_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_assign_target_pat(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_atom(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_atom(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_auto_accessor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AutoAccessor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_auto_accessor(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_auto_accessor(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_await_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AwaitExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_await_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_await_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_big_int<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigInt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_big_int(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_big_int(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_big_int_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigIntValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_big_int_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_big_int_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_bin_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_bin_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_bin_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_binary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_binary_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_binary_op(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_binding_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BindingIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_binding_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_binding_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_block_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_block_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmtOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_block_stmt_or_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_block_stmt_or_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_bool(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_bool(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_break_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BreakStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_break_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_break_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_call_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CallExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_call_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_call_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_callee(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_callee(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CatchClause,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_catch_clause(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_catch_clause(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class_member(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class_member(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ClassMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class_members(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class_members(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class_method(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class_method(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_class_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_class_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_class_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_computed_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComputedPropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_computed_prop_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_computed_prop_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_cond_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CondExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_cond_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_cond_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_constructor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Constructor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_constructor(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_constructor(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_continue_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContinueStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_continue_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_continue_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_debugger_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DebuggerStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_debugger_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_debugger_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_decl(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_decorator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Decorator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_decorator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_decorator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_decorators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Decorator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_decorators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_decorators(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_default_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_default_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_do_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DoWhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_do_while_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_do_while_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_empty_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EmptyStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_empty_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_empty_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_es_version<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EsVersion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_es_version(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_es_version(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_all<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportAll,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_all(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_all(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_default_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_default_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_default_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_default_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_default_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_default_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_default_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_named_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_named_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamespaceSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_namespace_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_namespace_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_export_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_export_specifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_export_specifiers(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_expr(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_expr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_expr_or_spread(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExprOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_expr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_expr_or_spreads(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_expr_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_expr_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_expr_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_exprs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<Expr>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_exprs(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_exprs(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_fn_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_fn_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_fn_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_fn_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_fn_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_fn_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_for_head<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForHead,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_for_head(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_for_head(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_for_in_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForInStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_for_in_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_for_in_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_for_of_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForOfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_for_of_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_for_of_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_for_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_for_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_for_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_function(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_getter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_getter_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_getter_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ident_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdentName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ident_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ident_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_if_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_if_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_if_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_default_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_default_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_named_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_named_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_phase<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPhase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_phase(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_phase(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_specifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_specifiers(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportStarAsSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_star_as_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_star_as_specifier(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_with<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWith,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_with(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_with(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_with_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWithItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_with_item(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_with_item(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_import_with_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportWithItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_import_with_items(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_import_with_items(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_invalid<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Invalid,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_invalid(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_invalid(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_attr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_attr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_attr_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_attr_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_attr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_attr_or_spread(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXAttrOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_attr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_attr_or_spreads(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_attr_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_attr_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_closing_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_closing_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_closing_fragment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_closing_fragment(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_element_child(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_element_child(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element_childs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXElementChild],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_element_childs(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_element_childs(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_element_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_element_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXEmptyExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_empty_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_empty_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_expr_container<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExprContainer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_expr_container(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_expr_container(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_fragment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_fragment(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXMemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_member_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_member_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXNamespacedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_namespaced_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_namespaced_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_object<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXObject,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_object(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_object(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_opening_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_opening_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_opening_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_opening_fragment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_opening_fragment(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_spread_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXSpreadChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_spread_child(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_spread_child(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_text<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXText,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_jsx_text(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_jsx_text(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_key(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_key(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValuePatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_key_value_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_key_value_pat_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_key_value_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValueProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_key_value_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_key_value_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_labeled_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LabeledStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_labeled_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_labeled_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_lit(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_lit(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_member_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_member_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_member_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_member_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_member_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_meta_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_meta_prop_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_meta_prop_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_meta_prop_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_meta_prop_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_meta_prop_kind(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_method_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_method_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_method_kind(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_method_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_method_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_method_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_module(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_module(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_module_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_module_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleExportName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_module_export_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_module_export_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_module_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_module_item(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_module_item(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_module_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ModuleItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_module_items(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_module_items(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_named_export<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedExport,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_named_export(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_named_export(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_new_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NewExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_new_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_new_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_null(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_null(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_number(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_number(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_object_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_object_lit(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_object_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_object_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_object_pat(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_object_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_object_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_object_pat_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_object_pat_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ObjectPatProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_object_pat_props(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_object_pat_props(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Accessibility>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_accessibility(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_accessibility(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<BlockStmt>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_block_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_block_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_call<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptCall,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_call(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_call(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<CatchClause>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_catch_clause(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_catch_clause(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_chain_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_chain_base(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_chain_base(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_chain_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_chain_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_chain_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Expr>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ExprOrSpread>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_expr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_expr_or_spread(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_expr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_expr_or_spreads(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXAttrValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_jsx_attr_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_jsx_attr_value(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXClosingElement>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_jsx_closing_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_jsx_closing_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ModuleExportName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_module_export_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_module_export_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ObjectLit>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_object_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_object_lit(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Pat>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_pat(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_common::Span>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_span(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_span(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Stmt>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_str<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Str>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_str(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_str(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TruePlusMinus>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_true_plus_minus(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_true_plus_minus(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsEntityName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ts_entity_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ts_entity_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsNamespaceBody>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ts_namespace_body(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ts_namespace_body(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ts_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ts_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ts_type_ann(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ts_type_ann(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ts_type_param_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ts_type_param_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_ts_type_param_instantiation(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_ts_type_param_instantiation(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<VarDeclOrExpr>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_var_decl_or_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_var_decl_or_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<ExprOrSpread>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_vec_expr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_vec_expr_or_spreads(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_vec_pats<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<Pat>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_opt_vec_pats(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_opt_vec_pats(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_param(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParamOrTsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_param_or_ts_param_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_param_or_ts_param_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ParamOrTsParamProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_param_or_ts_param_props(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_param_or_ts_param_props(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Param],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_params(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_params(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_paren_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParenExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_paren_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_paren_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_pat(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_pat(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_pats(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_pats(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_private_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_private_method(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_private_method(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_private_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_private_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_private_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_private_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_private_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_private_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_program<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Program,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_program(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_program(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_prop(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_prop_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_prop_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_prop_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_prop_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_prop_or_spread(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_prop_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PropOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_prop_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_prop_or_spreads(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_regex(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_regex(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_rest_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RestPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_rest_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_rest_pat(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_return_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ReturnStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_return_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_return_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_script(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_script(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_seq_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SeqExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_seq_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_seq_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_setter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_setter_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_setter_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_simple_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleAssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_simple_assign_target(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_simple_assign_target(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_span(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_span(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_spread_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SpreadElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_spread_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_spread_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_static_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StaticBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_static_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_static_block(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_stmt(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_stmts(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_stmts(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_super(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_super(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_super_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_super_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_super_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_super_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_super_prop_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_super_prop_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_switch_case<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchCase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_switch_case(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_switch_case(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_switch_cases<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SwitchCase],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_switch_cases(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_switch_cases(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_switch_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_switch_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_switch_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_syntax_context<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::SyntaxContext,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_syntax_context(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_syntax_context(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_tagged_tpl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TaggedTpl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_tagged_tpl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_tagged_tpl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_this_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThisExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_this_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_this_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_throw_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThrowStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_throw_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_throw_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAstPath::visit_tpl(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => VisitAstPath::visit_tpl(visitor, node, __ast_path),
-        }
-    }
-
-    #[inline]
-    fn visit_tpl_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TplElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_tpl_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_tpl_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_tpl_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TplElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_tpl_elements(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_tpl_elements(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TruePlusMinus,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_true_plus_minus(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_true_plus_minus(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_try_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TryStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_try_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_try_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_array_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsArrayType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_array_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_array_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_as_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsAsExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_as_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_as_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsCallSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_call_signature_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_call_signature_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_conditional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConditionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_conditional_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_conditional_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_const_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_const_assertion(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_const_assertion(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_construct_signature_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_construct_signature_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_constructor_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_constructor_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEntityName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_entity_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_entity_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_enum_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_enum_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_enum_member(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_enum_member(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMemberId,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_enum_member_id(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_enum_member_id(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsEnumMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_enum_members(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_enum_members(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_export_assignment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExportAssignment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_export_assignment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_export_assignment(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExprWithTypeArgs,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_expr_with_type_args(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_expr_with_type_args(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsExprWithTypeArgs],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_expr_with_type_argss(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_expr_with_type_argss(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExternalModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_external_module_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_external_module_ref(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnOrConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_fn_or_constructor_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_fn_or_constructor_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_fn_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_fn_param(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsFnParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_fn_params(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_fn_params(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_fn_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_fn_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_getter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsGetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_getter_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_getter_signature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportEqualsDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_import_equals_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_import_equals_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_import_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_import_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_import_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_index_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_index_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_index_signature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexedAccessType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_indexed_access_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_indexed_access_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_infer_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInferType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_infer_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_infer_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_instantiation(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_instantiation(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_interface_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_interface_body(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_interface_body(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_interface_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_interface_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_interface_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_intersection_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_intersection_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_keyword_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_keyword_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordTypeKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_keyword_type_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_keyword_type_kind(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_lit(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_lit_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_lit_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_mapped_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMappedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_mapped_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_mapped_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_method_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMethodSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_method_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_method_signature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_module_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_module_block(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_module_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_module_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_module_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_module_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_module_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_module_ref(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_namespace_body(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_namespace_body(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_namespace_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_namespace_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_namespace_export_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_namespace_export_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNonNullExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_non_null_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_non_null_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_optional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsOptionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_optional_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_optional_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_param_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_param_prop(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamPropParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_param_prop_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_param_prop_param(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParenthesizedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_parenthesized_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_parenthesized_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_property_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsPropertySignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_property_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_property_signature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_qualified_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsQualifiedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_qualified_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_qualified_name(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_rest_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsRestType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_rest_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_rest_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSatisfiesExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_satisfies_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_satisfies_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_setter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_setter_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_setter_signature(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_this_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_this_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_this_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisTypeOrIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_this_type_or_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_this_type_or_ident(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTplLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_tpl_lit_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_tpl_lit_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tuple_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_tuple_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_tuple_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTupleElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_tuple_elements(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_tuple_elements(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tuple_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_tuple_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_tuple_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAliasDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_alias_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_alias_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAnn,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_ann(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_ann(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_assertion(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_assertion(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_element(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_elements(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_elements(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_lit(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_operator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperatorOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_operator_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_operator_op(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_param(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_param_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_param_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_param_instantiation(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_param_instantiation(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_params(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_params(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_predicate<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypePredicate,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_predicate(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_predicate(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_query(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQueryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_query_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_query_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_type_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_type_ref(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<TsType>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_types(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionOrIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_union_or_intersection_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_union_or_intersection_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_ts_union_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_ts_union_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_ts_union_type(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_unary_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_unary_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_unary_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_unary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_unary_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_unary_op(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_update_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_update_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_update_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_update_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_update_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_update_op(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_using_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UsingDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_using_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_using_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_var_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_var_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_var_decl(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_var_decl_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_var_decl_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_var_decl_kind(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_var_decl_or_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_var_decl_or_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_var_declarator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclarator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_var_declarator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_var_declarator(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_var_declarators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [VarDeclarator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_var_declarators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_var_declarators(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_while_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_while_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_with_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WithStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_with_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_with_stmt(visitor, node, __ast_path)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_yield_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast YieldExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAstPath::visit_yield_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAstPath::visit_yield_expr(visitor, node, __ast_path)
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for ::swc_visit::Optional<V>
-where
-    V: VisitAstPath,
-{
-    #[inline]
-    fn visit_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Accessibility,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_accessibility(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_array_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_array_lit(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_array_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrayPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_array_pat(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_arrow_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ArrowExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_arrow_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_assign_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_assign_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_assign_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_assign_op(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_assign_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_assign_pat(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_assign_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_assign_pat_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_assign_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_assign_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_assign_target(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_assign_target_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AssignTargetPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_assign_target_pat(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_atoms::Atom,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_atom(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_auto_accessor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AutoAccessor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_auto_accessor(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_await_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast AwaitExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_await_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_big_int<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigInt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_big_int(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_big_int_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BigIntValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_big_int_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_bin_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_bin_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_binary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BinaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_binary_op(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_binding_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BindingIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_binding_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_block_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BlockStmtOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_block_stmt_or_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_bool(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_break_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast BreakStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_break_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_call_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CallExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_call_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_callee(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CatchClause,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_catch_clause(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class_member(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ClassMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class_members(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class_method(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_class_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ClassProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_class_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_computed_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ComputedPropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_computed_prop_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_cond_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast CondExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_cond_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_constructor<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Constructor,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_constructor(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_continue_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ContinueStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_continue_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_debugger_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DebuggerStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_debugger_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_decorator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Decorator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_decorator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_decorators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Decorator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_decorators(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_default_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_do_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast DoWhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_do_while_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_empty_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EmptyStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_empty_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_es_version<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast EsVersion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_es_version(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_all<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportAll,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_all(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_default_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_default_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_default_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_default_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_default_specifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_named_specifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportNamespaceSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_namespace_specifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_specifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_export_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_export_specifiers(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_expr_or_spread(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ExprOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_expr_or_spreads(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_expr_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ExprStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_expr_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_exprs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<Expr>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_exprs(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_fn_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_fn_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_fn_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast FnExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_fn_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_for_head<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForHead,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_for_head(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_for_in_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForInStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_for_in_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_for_of_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForOfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_for_of_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_for_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ForStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_for_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_function<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Function,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_function(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_getter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast GetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_getter_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ident_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IdentName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ident_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_if_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast IfStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_if_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_default_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportDefaultSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_default_specifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_named_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportNamedSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_named_specifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_phase<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportPhase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_phase(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_specifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_specifiers<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportSpecifier],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_specifiers(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportStarAsSpecifier,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_star_as_specifier(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_with<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWith,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_with(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_with_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ImportWithItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_with_item(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_import_with_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ImportWithItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_import_with_items(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_invalid<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Invalid,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_invalid(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_attr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_attr_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_attr_or_spread(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXAttrOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_attr_or_spreads(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXAttrValue,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_attr_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_closing_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXClosingFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_closing_fragment(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_element_child(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element_childs<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [JSXElementChild],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_element_childs(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_element_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXElementName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_element_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXEmptyExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_empty_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_expr_container<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXExprContainer,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_expr_container(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_fragment(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXMemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_member_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXNamespacedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_namespaced_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_object<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXObject,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_object(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_opening_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_opening_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXOpeningFragment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_opening_fragment(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_spread_child<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXSpreadChild,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_spread_child(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_jsx_text<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast JSXText,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_jsx_text(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_key(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValuePatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_key_value_pat_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_key_value_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast KeyValueProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_key_value_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_labeled_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast LabeledStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_labeled_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_lit(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_member_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_member_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_member_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MemberProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_member_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_meta_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_meta_prop_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_meta_prop_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MetaPropKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_meta_prop_kind(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_method_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_method_kind(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_method_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast MethodProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_method_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_module(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_module_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleExportName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_module_export_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_module_item<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ModuleItem,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_module_item(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_module_items<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ModuleItem],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_module_items(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_named_export<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NamedExport,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_named_export(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_new_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast NewExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_new_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_null(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_number(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_object_lit(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_object_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_object_pat(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_object_pat_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ObjectPatProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_object_pat_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_object_pat_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ObjectPatProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_object_pat_props(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_accessibility<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Accessibility>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_accessibility(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_atoms::Atom>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_atom(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_block_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<BlockStmt>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_block_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_call<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptCall,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_call(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_catch_clause<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<CatchClause>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_catch_clause(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_chain_base<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainBase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_chain_base(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_chain_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast OptChainExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_chain_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Expr>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ExprOrSpread>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_expr_or_spread(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_expr_or_spreads(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Ident>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXAttrValue>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_jsx_attr_value(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<JSXClosingElement>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_jsx_closing_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_module_export_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<ModuleExportName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_module_export_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_object_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<ObjectLit>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_object_lit(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Pat>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_pat(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<swc_common::Span>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_span(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Stmt>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_str<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<Str>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_str(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TruePlusMinus>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_true_plus_minus(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsEntityName>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ts_entity_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<TsNamespaceBody>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ts_namespace_body(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsType>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ts_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ts_type_ann(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ts_type_param_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Option<VarDeclOrExpr>,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_var_decl_or_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<ExprOrSpread>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_vec_pats<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Option<Pat>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_opt_vec_pats(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_param(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParamOrTsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_param_or_ts_param_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [ParamOrTsParamProp],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_param_or_ts_param_props(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Param],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_params(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_paren_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ParenExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_paren_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pat(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_pats(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_private_method<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateMethod,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_private_method(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_private_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_private_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_private_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PrivateProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_private_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_program<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast Program,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_program(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_prop_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_prop_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_prop_or_spread<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast PropOrSpread,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_prop_or_spread(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_prop_or_spreads<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [PropOrSpread],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_prop_or_spreads(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_regex(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_rest_pat<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast RestPat,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_rest_pat(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_return_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ReturnStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_return_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_script(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_seq_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SeqExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_seq_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_setter_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SetterProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_setter_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_simple_assign_target<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SimpleAssignTarget,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_simple_assign_target(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_span<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::Span,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_span(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_spread_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SpreadElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_spread_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_static_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast StaticBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_static_block(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_stmts(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_str(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_super(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_super_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_super_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_super_prop_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SuperPropExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_super_prop_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_switch_case<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchCase,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_switch_case(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_switch_cases<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [SwitchCase],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_switch_cases(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_switch_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast SwitchStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_switch_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_syntax_context<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast swc_common::SyntaxContext,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_syntax_context(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_tagged_tpl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TaggedTpl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_tagged_tpl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_this_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThisExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_this_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_throw_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast ThrowStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_throw_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_tpl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_tpl_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TplElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_tpl_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_tpl_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TplElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_tpl_elements(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_true_plus_minus<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TruePlusMinus,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_true_plus_minus(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_try_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TryStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_try_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_array_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsArrayType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_array_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_as_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsAsExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_as_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsCallSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_call_signature_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_conditional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConditionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_conditional_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_const_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_const_assertion(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructSignatureDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_construct_signature_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_constructor_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_entity_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEntityName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_entity_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_enum_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_member<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMember,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_enum_member(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsEnumMemberId,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_enum_member_id(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_enum_members<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsEnumMember],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_enum_members(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_export_assignment<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExportAssignment,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_export_assignment(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExprWithTypeArgs,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_expr_with_type_args(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsExprWithTypeArgs],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_expr_with_type_argss(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsExternalModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_external_module_ref(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnOrConstructorType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_fn_or_constructor_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_fn_param(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsFnParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_fn_params(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_fn_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsFnType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_fn_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_getter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsGetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_getter_signature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportEqualsDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_import_equals_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_import_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsImportType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_import_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_index_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_index_signature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIndexedAccessType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_indexed_access_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_infer_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInferType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_infer_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_instantiation(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_interface_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_interface_body(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_interface_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsInterfaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_interface_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_intersection_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_keyword_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsKeywordTypeKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_keyword_type_kind(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_lit(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_lit_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_mapped_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMappedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_mapped_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_method_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsMethodSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_method_signature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_block<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleBlock,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_module_block(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_module_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_module_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_module_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsModuleRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_module_ref(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_namespace_body<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceBody,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_namespace_body(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_namespace_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNamespaceExportDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_namespace_export_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsNonNullExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_non_null_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_optional_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsOptionalType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_optional_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_param_prop<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamProp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_param_prop(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParamPropParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_param_prop_param(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsParenthesizedType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_parenthesized_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_property_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsPropertySignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_property_signature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_qualified_name<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsQualifiedName,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_qualified_name(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_rest_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsRestType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_rest_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSatisfiesExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_satisfies_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_setter_signature<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsSetterSignature,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_setter_signature(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_this_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_this_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsThisTypeOrIdent,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_this_type_or_ident(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTplLitType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_tpl_lit_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tuple_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_tuple_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTupleElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_tuple_elements(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_tuple_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTupleType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_tuple_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAliasDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_alias_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_ann<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAnn,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_ann(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_assertion<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeAssertion,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_assertion(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_element<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeElement,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_element(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_elements<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeElement],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_elements(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_lit<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeLit,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_lit(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_operator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_operator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeOperatorOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_operator_op(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_param<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParam,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_param(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_param_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeParamInstantiation,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_param_instantiation(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_params<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [TsTypeParam],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_params(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_predicate<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypePredicate,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_predicate(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_query<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQuery,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_query(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeQueryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_query_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_type_ref<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsTypeRef,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_type_ref(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_types<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [Box<TsType>],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_types(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionOrIntersectionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_union_or_intersection_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_ts_union_type<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast TsUnionType,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_ts_union_type(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_unary_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_unary_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_unary_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UnaryOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_unary_op(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_update_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_update_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_update_op<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UpdateOp,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_update_op(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_using_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast UsingDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_using_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_var_decl<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDecl,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_var_decl(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_var_decl_kind<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclKind,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_var_decl_kind(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclOrExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_var_decl_or_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_var_declarator<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast VarDeclarator,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_var_declarator(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_var_declarators<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast [VarDeclarator],
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_var_declarators(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_while_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WhileStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_while_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_with_stmt<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast WithStmt,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_with_stmt(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_yield_expr<'ast: 'r, 'r>(
-        &mut self,
-        node: &'ast YieldExpr,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        if self.enabled {
-            <V as VisitAstPath>::visit_yield_expr(&mut self.visitor, node, __ast_path)
-        } else {
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for ::swc_visit::All<V> where V: VisitAll {}
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitWithAstPath<V: ?Sized + VisitAstPath> {
-    #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    );
-    #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    );
+pub trait VisitWith<V: ?Sized + Visit> {
+    #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
+    fn visit_with(&self, visitor: &mut V);
+    #[doc = r" Visit children nodes of `self`` with `visitor`."]
+    fn visit_children_with(&self, visitor: &mut V);
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Accessibility {
-    #[doc = "Calls [VisitAstPath`::visit_accessibility`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_accessibility(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Accessibility {
+    #[doc = "Calls [Visit`::visit_accessibility`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_accessibility(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Accessibility::Public => {}
             Accessibility::Protected => {}
@@ -34608,68 +9711,32 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Accessibility {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrayLit {
-    #[doc = "Calls [VisitAstPath`::visit_array_lit`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_array_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ArrayLit {
+    #[doc = "Calls [Visit`::visit_array_lit`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_array_lit(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ArrayLit { span, elems } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayLit(
-                        self,
-                        self::fields::ArrayLitField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayLit(
-                        self,
-                        self::fields::ArrayLitField::Elems(usize::MAX),
-                    ));
-                    <Vec<Option<ExprOrSpread>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        elems,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Option<ExprOrSpread>> as VisitWith<V>>::visit_with(elems, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrayPat {
-    #[doc = "Calls [VisitAstPath`::visit_array_pat`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_array_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ArrayPat {
+    #[doc = "Calls [Visit`::visit_array_pat`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_array_pat(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ArrayPat {
                 span,
@@ -34678,59 +9745,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrayPat {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayPat(
-                        self,
-                        self::fields::ArrayPatField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayPat(
-                        self,
-                        self::fields::ArrayPatField::Elems(usize::MAX),
-                    ));
-                    <Vec<Option<Pat>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        elems,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Option<Pat>> as VisitWith<V>>::visit_with(elems, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayPat(
-                        self,
-                        self::fields::ArrayPatField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrowExpr {
-    #[doc = "Calls [VisitAstPath`::visit_arrow_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_arrow_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ArrowExpr {
+    #[doc = "Calls [Visit`::visit_arrow_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_arrow_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ArrowExpr {
                 span,
@@ -34743,92 +9776,34 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrowExpr {
                 return_type,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
-                        self,
-                        self::fields::ArrowExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
-                        self,
-                        self::fields::ArrowExprField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
-                        self,
-                        self::fields::ArrowExprField::Params(usize::MAX),
-                    ));
-                    <Vec<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Pat> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
-                        self,
-                        self::fields::ArrowExprField::Body,
-                    ));
-                    <Box<BlockStmtOrExpr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<BlockStmtOrExpr> as VisitWith<V>>::visit_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
-                        self,
-                        self::fields::ArrowExprField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
-                        self,
-                        self::fields::ArrowExprField::ReturnType,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        return_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(return_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignExpr {
-    #[doc = "Calls [VisitAstPath`::visit_assign_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AssignExpr {
+    #[doc = "Calls [Visit`::visit_assign_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_assign_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AssignExpr {
                 span,
@@ -34837,70 +9812,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignExpr {
                 right,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
-                        self,
-                        self::fields::AssignExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
-                        self,
-                        self::fields::AssignExprField::Op,
-                    ));
-                    <AssignOp as VisitWithAstPath<V>>::visit_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <AssignOp as VisitWith<V>>::visit_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
-                        self,
-                        self::fields::AssignExprField::Left,
-                    ));
-                    <AssignTarget as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <AssignTarget as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
-                        self,
-                        self::fields::AssignExprField::Right,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignOp {
-    #[doc = "Calls [VisitAstPath`::visit_assign_op`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_op(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AssignOp {
+    #[doc = "Calls [Visit`::visit_assign_op`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_assign_op(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AssignOp::Assign => {}
             AssignOp::AddAssign => {}
@@ -34921,288 +9854,116 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignPat {
-    #[doc = "Calls [VisitAstPath`::visit_assign_pat`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AssignPat {
+    #[doc = "Calls [Visit`::visit_assign_pat`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_assign_pat(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AssignPat { span, left, right } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPat(
-                        self,
-                        self::fields::AssignPatField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPat(
-                        self,
-                        self::fields::AssignPatField::Left,
-                    ));
-                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPat(
-                        self,
-                        self::fields::AssignPatField::Right,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignPatProp {
-    #[doc = "Calls [VisitAstPath`::visit_assign_pat_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AssignPatProp {
+    #[doc = "Calls [Visit`::visit_assign_pat_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_assign_pat_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AssignPatProp { span, key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPatProp(
-                        self,
-                        self::fields::AssignPatPropField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPatProp(
-                        self,
-                        self::fields::AssignPatPropField::Key,
-                    ));
-                    <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BindingIdent as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPatProp(
-                        self,
-                        self::fields::AssignPatPropField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignProp {
-    #[doc = "Calls [VisitAstPath`::visit_assign_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AssignProp {
+    #[doc = "Calls [Visit`::visit_assign_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_assign_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AssignProp { span, key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignProp(
-                        self,
-                        self::fields::AssignPropField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignProp(
-                        self,
-                        self::fields::AssignPropField::Key,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignProp(
-                        self,
-                        self::fields::AssignPropField::Value,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignTarget {
-    #[doc = "Calls [VisitAstPath`::visit_assign_target`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_target(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AssignTarget {
+    #[doc = "Calls [Visit`::visit_assign_target`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_assign_target(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AssignTarget::Simple { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTarget(
-                    self,
-                    self::fields::AssignTargetField::Simple,
-                ));
-                <SimpleAssignTarget as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SimpleAssignTarget as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AssignTarget::Pat { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTarget(
-                    self,
-                    self::fields::AssignTargetField::Pat,
-                ));
-                <AssignTargetPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignTargetPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignTargetPat {
-    #[doc = "Calls [VisitAstPath`::visit_assign_target_pat`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_assign_target_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AssignTargetPat {
+    #[doc = "Calls [Visit`::visit_assign_target_pat`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_assign_target_pat(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AssignTargetPat::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTargetPat(
-                    self,
-                    self::fields::AssignTargetPatField::Array,
-                ));
-                <ArrayPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AssignTargetPat::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTargetPat(
-                    self,
-                    self::fields::AssignTargetPatField::Object,
-                ));
-                <ObjectPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             AssignTargetPat::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTargetPat(
-                    self,
-                    self::fields::AssignTargetPatField::Invalid,
-                ));
-                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AutoAccessor {
-    #[doc = "Calls [VisitAstPath`::visit_auto_accessor`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_auto_accessor(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AutoAccessor {
+    #[doc = "Calls [Visit`::visit_auto_accessor`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_auto_accessor(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AutoAccessor {
                 span,
@@ -35217,193 +9978,75 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AutoAccessor {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
-                        self,
-                        self::fields::AutoAccessorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
-                        self,
-                        self::fields::AutoAccessorField::Key,
-                    ));
-                    <Key as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Key as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
-                        self,
-                        self::fields::AutoAccessorField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
-                        self,
-                        self::fields::AutoAccessorField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
-                        self,
-                        self::fields::AutoAccessorField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
-                        self,
-                        self::fields::AutoAccessorField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AwaitExpr {
-    #[doc = "Calls [VisitAstPath`::visit_await_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_await_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for AwaitExpr {
+    #[doc = "Calls [Visit`::visit_await_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_await_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             AwaitExpr { span, arg } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AwaitExpr(
-                        self,
-                        self::fields::AwaitExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AwaitExpr(
-                        self,
-                        self::fields::AwaitExprField::Arg,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BigInt {
-    #[doc = "Calls [VisitAstPath`::visit_big_int`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_big_int(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BigInt {
+    #[doc = "Calls [Visit`::visit_big_int`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_big_int(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BigInt { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BigInt(
-                        self,
-                        self::fields::BigIntField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BigInt(
-                        self,
-                        self::fields::BigIntField::Value,
-                    ));
-                    <Box<BigIntValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<BigIntValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BigInt(
-                        self,
-                        self::fields::BigIntField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinExpr {
-    #[doc = "Calls [VisitAstPath`::visit_bin_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_bin_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BinExpr {
+    #[doc = "Calls [Visit`::visit_bin_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_bin_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BinExpr {
                 span,
@@ -35412,70 +10055,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinExpr {
                 right,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
-                        self,
-                        self::fields::BinExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
-                        self,
-                        self::fields::BinExprField::Op,
-                    ));
-                    <BinaryOp as VisitWithAstPath<V>>::visit_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BinaryOp as VisitWith<V>>::visit_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
-                        self,
-                        self::fields::BinExprField::Left,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
-                        self,
-                        self::fields::BinExprField::Right,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinaryOp {
-    #[doc = "Calls [VisitAstPath`::visit_binary_op`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_binary_op(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BinaryOp {
+    #[doc = "Calls [Visit`::visit_binary_op`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_binary_op(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BinaryOp::EqEq => {}
             BinaryOp::NotEq => {}
@@ -35505,244 +10106,106 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinaryOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BindingIdent {
-    #[doc = "Calls [VisitAstPath`::visit_binding_ident`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_binding_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BindingIdent {
+    #[doc = "Calls [Visit`::visit_binding_ident`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_binding_ident(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BindingIdent { id, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BindingIdent(
-                        self,
-                        self::fields::BindingIdentField::Id,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BindingIdent(
-                        self,
-                        self::fields::BindingIdentField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BlockStmt {
-    #[doc = "Calls [VisitAstPath`::visit_block_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_block_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BlockStmt {
+    #[doc = "Calls [Visit`::visit_block_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_block_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BlockStmt { span, ctxt, stmts } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmt(
-                        self,
-                        self::fields::BlockStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmt(
-                        self,
-                        self::fields::BlockStmtField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmt(
-                        self,
-                        self::fields::BlockStmtField::Stmts(usize::MAX),
-                    ));
-                    <Vec<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        stmts,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Stmt> as VisitWith<V>>::visit_with(stmts, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BlockStmtOrExpr {
-    #[doc = "Calls [VisitAstPath`::visit_block_stmt_or_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_block_stmt_or_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BlockStmtOrExpr {
+    #[doc = "Calls [Visit`::visit_block_stmt_or_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_block_stmt_or_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BlockStmtOrExpr::BlockStmt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmtOrExpr(
-                    self,
-                    self::fields::BlockStmtOrExprField::BlockStmt,
-                ));
-                <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BlockStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             BlockStmtOrExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmtOrExpr(
-                    self,
-                    self::fields::BlockStmtOrExprField::Expr,
-                ));
-                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Bool {
-    #[doc = "Calls [VisitAstPath`::visit_bool`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_bool(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Bool {
+    #[doc = "Calls [Visit`::visit_bool`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_bool(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Bool { span, value } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Bool(self, self::fields::BoolField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BreakStmt {
-    #[doc = "Calls [VisitAstPath`::visit_break_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_break_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for BreakStmt {
+    #[doc = "Calls [Visit`::visit_break_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_break_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             BreakStmt { span, label } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BreakStmt(
-                        self,
-                        self::fields::BreakStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BreakStmt(
-                        self,
-                        self::fields::BreakStmtField::Label,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(label, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CallExpr {
-    #[doc = "Calls [VisitAstPath`::visit_call_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_call_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CallExpr {
+    #[doc = "Calls [Visit`::visit_call_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_call_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CallExpr {
                 span,
@@ -35752,187 +10215,75 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CallExpr {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
-                        self,
-                        self::fields::CallExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
-                        self,
-                        self::fields::CallExprField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
-                        self,
-                        self::fields::CallExprField::Callee,
-                    ));
-                    <Callee as VisitWithAstPath<V>>::visit_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
-                        self,
-                        self::fields::CallExprField::Args(usize::MAX),
-                    ));
-                    <Vec<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                {
+                    <Callee as VisitWith<V>>::visit_with(callee, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
-                        self,
-                        self::fields::CallExprField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Vec<ExprOrSpread> as VisitWith<V>>::visit_with(args, visitor)
+                };
+                {
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Callee {
-    #[doc = "Calls [VisitAstPath`::visit_callee`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_callee(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Callee {
+    #[doc = "Calls [Visit`::visit_callee`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_callee(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Callee::Super { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Callee(
-                    self,
-                    self::fields::CalleeField::Super,
-                ));
-                <Super as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Super as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Callee::Import { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Callee(
-                    self,
-                    self::fields::CalleeField::Import,
-                ));
-                <Import as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Import as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Callee::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Callee(
-                    self,
-                    self::fields::CalleeField::Expr,
-                ));
-                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CatchClause {
-    #[doc = "Calls [VisitAstPath`::visit_catch_clause`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_catch_clause(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CatchClause {
+    #[doc = "Calls [Visit`::visit_catch_clause`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_catch_clause(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CatchClause { span, param, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CatchClause(
-                        self,
-                        self::fields::CatchClauseField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CatchClause(
-                        self,
-                        self::fields::CatchClauseField::Param,
-                    ));
-                    <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Pat> as VisitWith<V>>::visit_with(param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CatchClause(
-                        self,
-                        self::fields::CatchClauseField::Body,
-                    ));
-                    <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BlockStmt as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Class {
-    #[doc = "Calls [VisitAstPath`::visit_class`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Class {
+    #[doc = "Calls [Visit`::visit_class`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Class {
                 span,
@@ -35946,110 +10297,43 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Class {
                 implements,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::Body(usize::MAX),
-                    ));
-                    <Vec<ClassMember> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::SuperClass,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        super_class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ClassMember> as VisitWith<V>>::visit_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(super_class, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::SuperTypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (super_type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
-                        self,
-                        self::fields::ClassField::Implements(usize::MAX),
-                    ));
-                    <Vec<TsExprWithTypeArgs> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        implements,
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        super_type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                {
+                    <Vec<TsExprWithTypeArgs> as VisitWith<V>>::visit_with(implements, visitor)
+                };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassDecl {
-    #[doc = "Calls [VisitAstPath`::visit_class_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ClassDecl {
+    #[doc = "Calls [Visit`::visit_class_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ClassDecl {
                 ident,
@@ -36057,213 +10341,79 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassDecl {
                 class,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassDecl(
-                        self,
-                        self::fields::ClassDeclField::Ident,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassDecl(
-                        self,
-                        self::fields::ClassDeclField::Class,
-                    ));
-                    <Box<Class> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Class> as VisitWith<V>>::visit_with(class, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassExpr {
-    #[doc = "Calls [VisitAstPath`::visit_class_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ClassExpr {
+    #[doc = "Calls [Visit`::visit_class_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ClassExpr { ident, class } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassExpr(
-                        self,
-                        self::fields::ClassExprField::Ident,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassExpr(
-                        self,
-                        self::fields::ClassExprField::Class,
-                    ));
-                    <Box<Class> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Class> as VisitWith<V>>::visit_with(class, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassMember {
-    #[doc = "Calls [VisitAstPath`::visit_class_member`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_member(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ClassMember {
+    #[doc = "Calls [Visit`::visit_class_member`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class_member(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ClassMember::Constructor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::Constructor,
-                ));
-                <Constructor as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Constructor as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::Method { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::Method,
-                ));
-                <ClassMethod as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassMethod as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::PrivateMethod { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::PrivateMethod,
-                ));
-                <PrivateMethod as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateMethod as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::ClassProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::ClassProp,
-                ));
-                <ClassProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::PrivateProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::PrivateProp,
-                ));
-                <PrivateProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::TsIndexSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::TsIndexSignature,
-                ));
-                <TsIndexSignature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIndexSignature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::Empty { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::Empty,
-                ));
-                <EmptyStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <EmptyStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::StaticBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::StaticBlock,
-                ));
-                <StaticBlock as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <StaticBlock as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ClassMember::AutoAccessor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
-                    self,
-                    self::fields::ClassMemberField::AutoAccessor,
-                ));
-                <AutoAccessor as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AutoAccessor as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassMethod {
-    #[doc = "Calls [VisitAstPath`::visit_class_method`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_method(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ClassMethod {
+    #[doc = "Calls [Visit`::visit_class_method`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class_method(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ClassMethod {
                 span,
@@ -36277,81 +10427,31 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassMethod {
                 is_override,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
-                        self,
-                        self::fields::ClassMethodField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
-                        self,
-                        self::fields::ClassMethodField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
-                        self,
-                        self::fields::ClassMethodField::Function,
-                    ));
-                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
-                        self,
-                        self::fields::ClassMethodField::Kind,
-                    ));
-                    <MethodKind as VisitWithAstPath<V>>::visit_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MethodKind as VisitWith<V>>::visit_with(kind, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
-                        self,
-                        self::fields::ClassMethodField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassProp {
-    #[doc = "Calls [VisitAstPath`::visit_class_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ClassProp {
+    #[doc = "Calls [Visit`::visit_class_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ClassProp {
                 span,
@@ -36369,137 +10469,53 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassProp {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
-                        self,
-                        self::fields::ClassPropField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
-                        self,
-                        self::fields::ClassPropField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
-                        self,
-                        self::fields::ClassPropField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
-                        self,
-                        self::fields::ClassPropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
-                        self,
-                        self::fields::ClassPropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
-                        self,
-                        self::fields::ClassPropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComputedPropName {
-    #[doc = "Calls [VisitAstPath`::visit_computed_prop_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_computed_prop_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ComputedPropName {
+    #[doc = "Calls [Visit`::visit_computed_prop_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_computed_prop_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ComputedPropName { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComputedPropName(
-                        self,
-                        self::fields::ComputedPropNameField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComputedPropName(
-                        self,
-                        self::fields::ComputedPropNameField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CondExpr {
-    #[doc = "Calls [VisitAstPath`::visit_cond_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_cond_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for CondExpr {
+    #[doc = "Calls [Visit`::visit_cond_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_cond_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             CondExpr {
                 span,
@@ -36508,70 +10524,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CondExpr {
                 alt,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
-                        self,
-                        self::fields::CondExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
-                        self,
-                        self::fields::CondExprField::Test,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
-                        self,
-                        self::fields::CondExprField::Cons,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(cons, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
-                        self,
-                        self::fields::CondExprField::Alt,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        alt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(alt, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Constructor {
-    #[doc = "Calls [VisitAstPath`::visit_constructor`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_constructor(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Constructor {
+    #[doc = "Calls [Visit`::visit_constructor`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_constructor(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Constructor {
                 span,
@@ -36583,461 +10557,181 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Constructor {
                 is_optional,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
-                        self,
-                        self::fields::ConstructorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
-                        self,
-                        self::fields::ConstructorField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
-                        self,
-                        self::fields::ConstructorField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
-                        self,
-                        self::fields::ConstructorField::Params(usize::MAX),
-                    ));
-                    <Vec<ParamOrTsParamProp> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ParamOrTsParamProp> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
-                        self,
-                        self::fields::ConstructorField::Body,
-                    ));
-                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
-                        self,
-                        self::fields::ConstructorField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContinueStmt {
-    #[doc = "Calls [VisitAstPath`::visit_continue_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_continue_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ContinueStmt {
+    #[doc = "Calls [Visit`::visit_continue_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_continue_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ContinueStmt { span, label } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContinueStmt(
-                        self,
-                        self::fields::ContinueStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContinueStmt(
-                        self,
-                        self::fields::ContinueStmtField::Label,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(label, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DebuggerStmt {
-    #[doc = "Calls [VisitAstPath`::visit_debugger_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_debugger_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DebuggerStmt {
+    #[doc = "Calls [Visit`::visit_debugger_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_debugger_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DebuggerStmt { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DebuggerStmt(
-                        self,
-                        self::fields::DebuggerStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Decl {
-    #[doc = "Calls [VisitAstPath`::visit_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Decl {
+    #[doc = "Calls [Visit`::visit_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Decl::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Class));
-                <ClassDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Decl::Fn { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Fn));
-                <FnDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FnDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Decl::Var { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Var));
-                <Box<VarDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<VarDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Decl::Using { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Using));
-                <Box<UsingDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<UsingDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Decl::TsInterface { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
-                    self,
-                    self::fields::DeclField::TsInterface,
-                ));
-                <Box<TsInterfaceDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsInterfaceDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Decl::TsTypeAlias { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
-                    self,
-                    self::fields::DeclField::TsTypeAlias,
-                ));
-                <Box<TsTypeAliasDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsTypeAliasDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Decl::TsEnum { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
-                    self,
-                    self::fields::DeclField::TsEnum,
-                ));
-                <Box<TsEnumDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsEnumDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Decl::TsModule { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
-                    self,
-                    self::fields::DeclField::TsModule,
-                ));
-                <Box<TsModuleDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsModuleDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Decorator {
-    #[doc = "Calls [VisitAstPath`::visit_decorator`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_decorator(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Decorator {
+    #[doc = "Calls [Visit`::visit_decorator`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_decorator(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Decorator { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decorator(
-                        self,
-                        self::fields::DecoratorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decorator(
-                        self,
-                        self::fields::DecoratorField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DefaultDecl {
-    #[doc = "Calls [VisitAstPath`::visit_default_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_default_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DefaultDecl {
+    #[doc = "Calls [Visit`::visit_default_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_default_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DefaultDecl::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DefaultDecl(
-                    self,
-                    self::fields::DefaultDeclField::Class,
-                ));
-                <ClassExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             DefaultDecl::Fn { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DefaultDecl(
-                    self,
-                    self::fields::DefaultDeclField::Fn,
-                ));
-                <FnExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FnExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             DefaultDecl::TsInterfaceDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DefaultDecl(
-                    self,
-                    self::fields::DefaultDeclField::TsInterfaceDecl,
-                ));
-                <Box<TsInterfaceDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsInterfaceDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DoWhileStmt {
-    #[doc = "Calls [VisitAstPath`::visit_do_while_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_do_while_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for DoWhileStmt {
+    #[doc = "Calls [Visit`::visit_do_while_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_do_while_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             DoWhileStmt { span, test, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DoWhileStmt(
-                        self,
-                        self::fields::DoWhileStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DoWhileStmt(
-                        self,
-                        self::fields::DoWhileStmtField::Test,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DoWhileStmt(
-                        self,
-                        self::fields::DoWhileStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
+                };
+                {
+                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for EmptyStmt {
-    #[doc = "Calls [VisitAstPath`::visit_empty_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_empty_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for EmptyStmt {
+    #[doc = "Calls [Visit`::visit_empty_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_empty_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             EmptyStmt { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::EmptyStmt(
-                        self,
-                        self::fields::EmptyStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for EsVersion {
-    #[doc = "Calls [VisitAstPath`::visit_es_version`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_es_version(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for EsVersion {
+    #[doc = "Calls [Visit`::visit_es_version`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_es_version(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             EsVersion::Es3 => {}
             EsVersion::Es5 => {}
@@ -37053,23 +10747,13 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for EsVersion {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportAll {
-    #[doc = "Calls [VisitAstPath`::visit_export_all`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_all(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportAll {
+    #[doc = "Calls [Visit`::visit_export_all`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_all(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportAll {
                 span,
@@ -37078,233 +10762,98 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportAll {
                 with,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportAll(
-                        self,
-                        self::fields::ExportAllField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportAll(
-                        self,
-                        self::fields::ExportAllField::Src,
-                    ));
-                    <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Str> as VisitWith<V>>::visit_with(src, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportAll(
-                        self,
-                        self::fields::ExportAllField::With,
-                    ));
-                    <Option<Box<ObjectLit>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ObjectLit>> as VisitWith<V>>::visit_with(with, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDecl {
-    #[doc = "Calls [VisitAstPath`::visit_export_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportDecl {
+    #[doc = "Calls [Visit`::visit_export_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportDecl { span, decl } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportDecl(
-                        self,
-                        self::fields::ExportDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportDecl(
-                        self,
-                        self::fields::ExportDeclField::Decl,
-                    ));
-                    <Decl as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decl,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Decl as VisitWith<V>>::visit_with(decl, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDefaultDecl {
-    #[doc = "Calls [VisitAstPath`::visit_export_default_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportDefaultDecl {
+    #[doc = "Calls [Visit`::visit_export_default_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_default_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportDefaultDecl { span, decl } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultDecl(
-                            self,
-                            self::fields::ExportDefaultDeclField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultDecl(
-                            self,
-                            self::fields::ExportDefaultDeclField::Decl,
-                        ));
-                    <DefaultDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decl,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <DefaultDecl as VisitWith<V>>::visit_with(decl, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDefaultExpr {
-    #[doc = "Calls [VisitAstPath`::visit_export_default_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportDefaultExpr {
+    #[doc = "Calls [Visit`::visit_export_default_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_default_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportDefaultExpr { span, expr } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultExpr(
-                            self,
-                            self::fields::ExportDefaultExprField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultExpr(
-                            self,
-                            self::fields::ExportDefaultExprField::Expr,
-                        ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDefaultSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_export_default_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_default_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportDefaultSpecifier {
+    #[doc = "Calls [Visit`::visit_export_default_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_default_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportDefaultSpecifier { exported } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultSpecifier(
-                            self,
-                            self::fields::ExportDefaultSpecifierField::Exported,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        exported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(exported, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportNamedSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_export_named_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_named_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportNamedSpecifier {
+    #[doc = "Calls [Visit`::visit_export_named_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_named_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportNamedSpecifier {
                 span,
@@ -37313,656 +10862,227 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportNamedSpecifier {
                 is_type_only,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportNamedSpecifier(
-                            self,
-                            self::fields::ExportNamedSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportNamedSpecifier(
-                            self,
-                            self::fields::ExportNamedSpecifierField::Orig,
-                        ));
-                    <ModuleExportName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        orig,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ModuleExportName as VisitWith<V>>::visit_with(orig, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportNamedSpecifier(
-                            self,
-                            self::fields::ExportNamedSpecifierField::Exported,
-                        ));
-                    <Option<ModuleExportName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        exported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ModuleExportName> as VisitWith<V>>::visit_with(exported, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportNamespaceSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_export_namespace_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_namespace_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportNamespaceSpecifier {
+    #[doc = "Calls [Visit`::visit_export_namespace_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_namespace_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportNamespaceSpecifier { span, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportNamespaceSpecifier(
-                            self,
-                            self::fields::ExportNamespaceSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ExportNamespaceSpecifier(
-                            self,
-                            self::fields::ExportNamespaceSpecifierField::Name,
-                        ));
-                    <ModuleExportName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ModuleExportName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_export_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExportSpecifier {
+    #[doc = "Calls [Visit`::visit_export_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExportSpecifier::Namespace { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportSpecifier(
-                    self,
-                    self::fields::ExportSpecifierField::Namespace,
-                ));
-                <ExportNamespaceSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportNamespaceSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ExportSpecifier::Default { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportSpecifier(
-                    self,
-                    self::fields::ExportSpecifierField::Default,
-                ));
-                <ExportDefaultSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDefaultSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ExportSpecifier::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportSpecifier(
-                    self,
-                    self::fields::ExportSpecifierField::Named,
-                ));
-                <ExportNamedSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportNamedSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Expr {
-    #[doc = "Calls [VisitAstPath`::visit_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Expr {
+    #[doc = "Calls [Visit`::visit_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Expr::This { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::This));
-                <ThisExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ThisExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Array));
-                <ArrayLit as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayLit as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Object,
-                ));
-                <ObjectLit as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectLit as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Fn { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Fn));
-                <FnExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FnExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Unary { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Unary));
-                <UnaryExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UnaryExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Update { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Update,
-                ));
-                <UpdateExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UpdateExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Bin { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Bin));
-                <BinExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BinExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Assign,
-                ));
-                <AssignExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Member { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Member,
-                ));
-                <MemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::SuperProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::SuperProp,
-                ));
-                <SuperPropExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SuperPropExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Cond { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Cond));
-                <CondExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CondExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Call { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Call));
-                <CallExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CallExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::New { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::New));
-                <NewExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NewExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Seq { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Seq));
-                <SeqExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SeqExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Ident));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Lit { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Lit));
-                <Lit as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Lit as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Tpl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Tpl));
-                <Tpl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Tpl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::TaggedTpl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::TaggedTpl,
-                ));
-                <TaggedTpl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TaggedTpl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Arrow { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Arrow));
-                <ArrowExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrowExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Class));
-                <ClassExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Yield { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Yield));
-                <YieldExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <YieldExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::MetaProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::MetaProp,
-                ));
-                <MetaPropExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MetaPropExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Await { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Await));
-                <AwaitExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AwaitExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Paren { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Paren));
-                <ParenExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ParenExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::JSXMember { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Jsxmember,
-                ));
-                <JSXMemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXMemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::JsxnamespacedName,
-                ));
-                <JSXNamespacedName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXNamespacedName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::JSXEmpty { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Jsxempty,
-                ));
-                <JSXEmptyExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXEmptyExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::JSXElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Jsxelement,
-                ));
-                <Box<JSXElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXElement> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Jsxfragment,
-                ));
-                <JSXFragment as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXFragment as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::TsTypeAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::TsTypeAssertion,
-                ));
-                <TsTypeAssertion as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeAssertion as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::TsConstAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::TsConstAssertion,
-                ));
-                <TsConstAssertion as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConstAssertion as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::TsNonNull { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::TsNonNull,
-                ));
-                <TsNonNullExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNonNullExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::TsAs { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::TsAs));
-                <TsAsExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsAsExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::TsInstantiation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::TsInstantiation,
-                ));
-                <TsInstantiation as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsInstantiation as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::TsSatisfies { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::TsSatisfies,
-                ));
-                <TsSatisfiesExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsSatisfiesExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::PrivateName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::PrivateName,
-                ));
-                <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::OptChain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::OptChain,
-                ));
-                <OptChainExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <OptChainExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Expr::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
-                    self,
-                    self::fields::ExprField::Invalid,
-                ));
-                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExprOrSpread {
-    #[doc = "Calls [VisitAstPath`::visit_expr_or_spread`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExprOrSpread {
+    #[doc = "Calls [Visit`::visit_expr_or_spread`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_expr_or_spread(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExprOrSpread { spread, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprOrSpread(
-                        self,
-                        self::fields::ExprOrSpreadField::Spread,
-                    ));
-                    <Option<swc_common::Span> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        spread,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_common::Span> as VisitWith<V>>::visit_with(spread, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprOrSpread(
-                        self,
-                        self::fields::ExprOrSpreadField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExprStmt {
-    #[doc = "Calls [VisitAstPath`::visit_expr_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ExprStmt {
+    #[doc = "Calls [Visit`::visit_expr_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_expr_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ExprStmt { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprStmt(
-                        self,
-                        self::fields::ExprStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprStmt(
-                        self,
-                        self::fields::ExprStmtField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FnDecl {
-    #[doc = "Calls [VisitAstPath`::visit_fn_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_fn_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for FnDecl {
+    #[doc = "Calls [Visit`::visit_fn_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_fn_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             FnDecl {
                 ident,
@@ -37970,219 +11090,91 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FnDecl {
                 function,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnDecl(
-                        self,
-                        self::fields::FnDeclField::Ident,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnDecl(
-                        self,
-                        self::fields::FnDeclField::Function,
-                    ));
-                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FnExpr {
-    #[doc = "Calls [VisitAstPath`::visit_fn_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_fn_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for FnExpr {
+    #[doc = "Calls [Visit`::visit_fn_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_fn_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             FnExpr { ident, function } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnExpr(
-                        self,
-                        self::fields::FnExprField::Ident,
-                    ));
-                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitWith<V>>::visit_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnExpr(
-                        self,
-                        self::fields::FnExprField::Function,
-                    ));
-                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForHead {
-    #[doc = "Calls [VisitAstPath`::visit_for_head`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_head(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForHead {
+    #[doc = "Calls [Visit`::visit_for_head`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_for_head(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ForHead::VarDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForHead(
-                    self,
-                    self::fields::ForHeadField::VarDecl,
-                ));
-                <Box<VarDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<VarDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ForHead::UsingDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForHead(
-                    self,
-                    self::fields::ForHeadField::UsingDecl,
-                ));
-                <Box<UsingDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<UsingDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ForHead::Pat { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForHead(
-                    self,
-                    self::fields::ForHeadField::Pat,
-                ));
-                <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Pat> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForInStmt {
-    #[doc = "Calls [VisitAstPath`::visit_for_in_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_in_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForInStmt {
+    #[doc = "Calls [Visit`::visit_for_in_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_for_in_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            ForInStmt {
-                span,
-                left,
-                right,
-                body,
-            } => {
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
-                        self,
-                        self::fields::ForInStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+            ForInStmt {
+                span,
+                left,
+                right,
+                body,
+            } => {
+                {
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
-                        self,
-                        self::fields::ForInStmtField::Left,
-                    ));
-                    <ForHead as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ForHead as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
-                        self,
-                        self::fields::ForInStmtField::Right,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
-                        self,
-                        self::fields::ForInStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForOfStmt {
-    #[doc = "Calls [VisitAstPath`::visit_for_of_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_of_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForOfStmt {
+    #[doc = "Calls [Visit`::visit_for_of_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_for_of_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ForOfStmt {
                 span,
@@ -38192,70 +11184,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForOfStmt {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
-                        self,
-                        self::fields::ForOfStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
-                        self,
-                        self::fields::ForOfStmtField::Left,
-                    ));
-                    <ForHead as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ForHead as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
-                        self,
-                        self::fields::ForOfStmtField::Right,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(right, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
-                        self,
-                        self::fields::ForOfStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForStmt {
-    #[doc = "Calls [VisitAstPath`::visit_for_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_for_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ForStmt {
+    #[doc = "Calls [Visit`::visit_for_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_for_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ForStmt {
                 span,
@@ -38265,81 +11215,31 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForStmt {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
-                        self,
-                        self::fields::ForStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
-                        self,
-                        self::fields::ForStmtField::Init,
-                    ));
-                    <Option<VarDeclOrExpr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<VarDeclOrExpr> as VisitWith<V>>::visit_with(init, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
-                        self,
-                        self::fields::ForStmtField::Test,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
-                        self,
-                        self::fields::ForStmtField::Update,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        update,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(update, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
-                        self,
-                        self::fields::ForStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Function {
-    #[doc = "Calls [VisitAstPath`::visit_function`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_function(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Function {
+    #[doc = "Calls [Visit`::visit_function`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_function(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Function {
                 params,
@@ -38353,103 +11253,37 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Function {
                 return_type,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Params(usize::MAX),
-                    ));
-                    <Vec<Param> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Param> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::Body,
-                    ));
-                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
-                        self,
-                        self::fields::FunctionField::ReturnType,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        return_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(return_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for GetterProp {
-    #[doc = "Calls [VisitAstPath`::visit_getter_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_getter_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for GetterProp {
+    #[doc = "Calls [Visit`::visit_getter_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_getter_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             GetterProp {
                 span,
@@ -38458,70 +11292,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for GetterProp {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
-                        self,
-                        self::fields::GetterPropField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
-                        self,
-                        self::fields::GetterPropField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
-                        self,
-                        self::fields::GetterPropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
-                        self,
-                        self::fields::GetterPropField::Body,
-                    ));
-                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Ident {
-    #[doc = "Calls [VisitAstPath`::visit_ident`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Ident {
+    #[doc = "Calls [Visit`::visit_ident`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ident(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Ident {
                 span,
@@ -38530,102 +11322,44 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Ident {
                 optional,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
-                        self,
-                        self::fields::IdentField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
-                        self,
-                        self::fields::IdentField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Ident(self, self::fields::IdentField::Sym));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        sym,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(sym, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for IdentName {
-    #[doc = "Calls [VisitAstPath`::visit_ident_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ident_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for IdentName {
+    #[doc = "Calls [Visit`::visit_ident_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ident_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             IdentName { span, sym } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdentName(
-                        self,
-                        self::fields::IdentNameField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdentName(
-                        self,
-                        self::fields::IdentNameField::Sym,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        sym,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(sym, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for IfStmt {
-    #[doc = "Calls [VisitAstPath`::visit_if_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_if_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for IfStmt {
+    #[doc = "Calls [Visit`::visit_if_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_if_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             IfStmt {
                 span,
@@ -38634,115 +11368,47 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for IfStmt {
                 alt,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
-                        self,
-                        self::fields::IfStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
-                        self,
-                        self::fields::IfStmtField::Test,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
-                        self,
-                        self::fields::IfStmtField::Cons,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitWith<V>>::visit_with(cons, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
-                        self,
-                        self::fields::IfStmtField::Alt,
-                    ));
-                    <Option<Box<Stmt>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        alt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Stmt>> as VisitWith<V>>::visit_with(alt, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Import {
-    #[doc = "Calls [VisitAstPath`::visit_import`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Import {
+    #[doc = "Calls [Visit`::visit_import`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Import { span, phase } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Import(
-                        self,
-                        self::fields::ImportField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Import(
-                        self,
-                        self::fields::ImportField::Phase,
-                    ));
-                    <ImportPhase as VisitWithAstPath<V>>::visit_with_ast_path(
-                        phase,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ImportPhase as VisitWith<V>>::visit_with(phase, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportDecl {
-    #[doc = "Calls [VisitAstPath`::visit_import_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportDecl {
+    #[doc = "Calls [Visit`::visit_import_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportDecl {
                 span,
@@ -38753,128 +11419,50 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportDecl {
                 phase,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
-                        self,
-                        self::fields::ImportDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
-                        self,
-                        self::fields::ImportDeclField::Specifiers(usize::MAX),
-                    ));
-                    <Vec<ImportSpecifier> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        specifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ImportSpecifier> as VisitWith<V>>::visit_with(specifiers, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
-                        self,
-                        self::fields::ImportDeclField::Src,
-                    ));
-                    <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Str> as VisitWith<V>>::visit_with(src, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
-                        self,
-                        self::fields::ImportDeclField::With,
-                    ));
-                    <Option<Box<ObjectLit>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ObjectLit>> as VisitWith<V>>::visit_with(with, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
-                        self,
-                        self::fields::ImportDeclField::Phase,
-                    ));
-                    <ImportPhase as VisitWithAstPath<V>>::visit_with_ast_path(
-                        phase,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ImportPhase as VisitWith<V>>::visit_with(phase, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportDefaultSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_import_default_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_default_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportDefaultSpecifier {
+    #[doc = "Calls [Visit`::visit_import_default_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_default_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportDefaultSpecifier { span, local } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ImportDefaultSpecifier(
-                            self,
-                            self::fields::ImportDefaultSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ImportDefaultSpecifier(
-                            self,
-                            self::fields::ImportDefaultSpecifierField::Local,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(local, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportNamedSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_import_named_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_named_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportNamedSpecifier {
+    #[doc = "Calls [Visit`::visit_import_named_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_named_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportNamedSpecifier {
                 span,
@@ -38883,62 +11471,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportNamedSpecifier {
                 is_type_only,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ImportNamedSpecifier(
-                            self,
-                            self::fields::ImportNamedSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ImportNamedSpecifier(
-                            self,
-                            self::fields::ImportNamedSpecifierField::Local,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(local, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ImportNamedSpecifier(
-                            self,
-                            self::fields::ImportNamedSpecifierField::Imported,
-                        ));
-                    <Option<ModuleExportName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        imported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ModuleExportName> as VisitWith<V>>::visit_with(imported, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportPhase {
-    #[doc = "Calls [VisitAstPath`::visit_import_phase`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_phase(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportPhase {
+    #[doc = "Calls [Visit`::visit_import_phase`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_phase(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportPhase::Evaluation => {}
             ImportPhase::Source => {}
@@ -38946,537 +11497,220 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportPhase {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_import_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportSpecifier {
+    #[doc = "Calls [Visit`::visit_import_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportSpecifier::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportSpecifier(
-                    self,
-                    self::fields::ImportSpecifierField::Named,
-                ));
-                <ImportNamedSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportNamedSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ImportSpecifier::Default { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportSpecifier(
-                    self,
-                    self::fields::ImportSpecifierField::Default,
-                ));
-                <ImportDefaultSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportDefaultSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ImportSpecifier::Namespace { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportSpecifier(
-                    self,
-                    self::fields::ImportSpecifierField::Namespace,
-                ));
-                <ImportStarAsSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportStarAsSpecifier as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportStarAsSpecifier {
-    #[doc = "Calls [VisitAstPath`::visit_import_star_as_specifier`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_star_as_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportStarAsSpecifier {
+    #[doc = "Calls [Visit`::visit_import_star_as_specifier`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_star_as_specifier(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportStarAsSpecifier { span, local } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ImportStarAsSpecifier(
-                            self,
-                            self::fields::ImportStarAsSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::ImportStarAsSpecifier(
-                            self,
-                            self::fields::ImportStarAsSpecifierField::Local,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(local, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportWith {
-    #[doc = "Calls [VisitAstPath`::visit_import_with`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportWith {
+    #[doc = "Calls [Visit`::visit_import_with`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_with(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportWith { span, values } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWith(
-                        self,
-                        self::fields::ImportWithField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWith(
-                        self,
-                        self::fields::ImportWithField::Values(usize::MAX),
-                    ));
-                    <Vec<ImportWithItem> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        values,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ImportWithItem> as VisitWith<V>>::visit_with(values, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportWithItem {
-    #[doc = "Calls [VisitAstPath`::visit_import_with_item`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with_item(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ImportWithItem {
+    #[doc = "Calls [Visit`::visit_import_with_item`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_with_item(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ImportWithItem { key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWithItem(
-                        self,
-                        self::fields::ImportWithItemField::Key,
-                    ));
-                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWithItem(
-                        self,
-                        self::fields::ImportWithItemField::Value,
-                    ));
-                    <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Str as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Invalid {
-    #[doc = "Calls [VisitAstPath`::visit_invalid`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_invalid(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Invalid {
+    #[doc = "Calls [Visit`::visit_invalid`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_invalid(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Invalid { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Invalid(
-                        self,
-                        self::fields::InvalidField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttr {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_attr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXAttr {
+    #[doc = "Calls [Visit`::visit_jsx_attr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_attr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXAttr { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttr(
-                        self,
-                        self::fields::JSXAttrField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttr(
-                        self,
-                        self::fields::JSXAttrField::Name,
-                    ));
-                    <JSXAttrName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXAttrName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttr(
-                        self,
-                        self::fields::JSXAttrField::Value,
-                    ));
-                    <Option<JSXAttrValue> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<JSXAttrValue> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttrName {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXAttrName {
+    #[doc = "Calls [Visit`::visit_jsx_attr_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_attr_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXAttrName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrName(
-                    self,
-                    self::fields::JSXAttrNameField::Ident,
-                ));
-                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXAttrName::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrName(
-                    self,
-                    self::fields::JSXAttrNameField::JsxnamespacedName,
-                ));
-                <JSXNamespacedName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXNamespacedName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttrOrSpread {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_or_spread`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXAttrOrSpread {
+    #[doc = "Calls [Visit`::visit_jsx_attr_or_spread`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_attr_or_spread(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrOrSpread(
-                    self,
-                    self::fields::JSXAttrOrSpreadField::Jsxattr,
-                ));
-                <JSXAttr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrOrSpread(
-                    self,
-                    self::fields::JSXAttrOrSpreadField::SpreadElement,
-                ));
-                <SpreadElement as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+            JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
+                <JSXAttr as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
+                <SpreadElement as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttrValue {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_value`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_value(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXAttrValue {
+    #[doc = "Calls [Visit`::visit_jsx_attr_value`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_attr_value(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXAttrValue::Lit { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
-                    self,
-                    self::fields::JSXAttrValueField::Lit,
-                ));
-                <Lit as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Lit as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXAttrValue::JSXExprContainer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
-                    self,
-                    self::fields::JSXAttrValueField::JsxexprContainer,
-                ));
-                <JSXExprContainer as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXExprContainer as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXAttrValue::JSXElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
-                    self,
-                    self::fields::JSXAttrValueField::Jsxelement,
-                ));
-                <Box<JSXElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXElement> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXAttrValue::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
-                    self,
-                    self::fields::JSXAttrValueField::Jsxfragment,
-                ));
-                <JSXFragment as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXFragment as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXClosingElement {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_closing_element`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_closing_element(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXClosingElement {
+    #[doc = "Calls [Visit`::visit_jsx_closing_element`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_closing_element(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXClosingElement { span, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXClosingElement(
-                            self,
-                            self::fields::JSXClosingElementField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXClosingElement(
-                            self,
-                            self::fields::JSXClosingElementField::Name,
-                        ));
-                    <JSXElementName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXElementName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXClosingFragment {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_closing_fragment`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_closing_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXClosingFragment {
+    #[doc = "Calls [Visit`::visit_jsx_closing_fragment`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_closing_fragment(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXClosingFragment { span } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXClosingFragment(
-                            self,
-                            self::fields::JSXClosingFragmentField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXElement {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_element`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXElement {
+    #[doc = "Calls [Visit`::visit_jsx_element`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_element(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXElement {
                 span,
@@ -39485,322 +11719,126 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXElement {
                 closing,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
-                        self,
-                        self::fields::JSXElementField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
-                        self,
-                        self::fields::JSXElementField::Opening,
-                    ));
-                    <JSXOpeningElement as VisitWithAstPath<V>>::visit_with_ast_path(
-                        opening,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXOpeningElement as VisitWith<V>>::visit_with(opening, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
-                        self,
-                        self::fields::JSXElementField::Children(usize::MAX),
-                    ));
-                    <Vec<JSXElementChild> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<JSXElementChild> as VisitWith<V>>::visit_with(children, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
-                        self,
-                        self::fields::JSXElementField::Closing,
-                    ));
-                    <Option<JSXClosingElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        closing,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<JSXClosingElement> as VisitWith<V>>::visit_with(closing, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXElementChild {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_element_child`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_child(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXElementChild {
+    #[doc = "Calls [Visit`::visit_jsx_element_child`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_element_child(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXElementChild::JSXText { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
-                    self,
-                    self::fields::JSXElementChildField::Jsxtext,
-                ));
-                <JSXText as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXText as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXElementChild::JSXExprContainer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
-                    self,
-                    self::fields::JSXElementChildField::JsxexprContainer,
-                ));
-                <JSXExprContainer as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXExprContainer as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXElementChild::JSXSpreadChild { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
-                    self,
-                    self::fields::JSXElementChildField::JsxspreadChild,
-                ));
-                <JSXSpreadChild as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXSpreadChild as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXElementChild::JSXElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
-                    self,
-                    self::fields::JSXElementChildField::Jsxelement,
-                ));
-                <Box<JSXElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXElement> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXElementChild::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
-                    self,
-                    self::fields::JSXElementChildField::Jsxfragment,
-                ));
-                <JSXFragment as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXFragment as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXElementName {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_element_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXElementName {
+    #[doc = "Calls [Visit`::visit_jsx_element_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_element_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXElementName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementName(
-                    self,
-                    self::fields::JSXElementNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXElementName::JSXMemberExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementName(
-                    self,
-                    self::fields::JSXElementNameField::JsxmemberExpr,
-                ));
-                <JSXMemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXMemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXElementName::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementName(
-                    self,
-                    self::fields::JSXElementNameField::JsxnamespacedName,
-                ));
-                <JSXNamespacedName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXNamespacedName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXEmptyExpr {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_empty_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_empty_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXEmptyExpr {
+    #[doc = "Calls [Visit`::visit_jsx_empty_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_empty_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXEmptyExpr { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXEmptyExpr(
-                        self,
-                        self::fields::JSXEmptyExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXExpr {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXExpr {
+    #[doc = "Calls [Visit`::visit_jsx_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXExpr::JSXEmptyExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExpr(
-                    self,
-                    self::fields::JSXExprField::JsxemptyExpr,
-                ));
-                <JSXEmptyExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXEmptyExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExpr(
-                    self,
-                    self::fields::JSXExprField::Expr,
-                ));
-                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXExprContainer {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_expr_container`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_expr_container(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXExprContainer {
+    #[doc = "Calls [Visit`::visit_jsx_expr_container`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_expr_container(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXExprContainer { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExprContainer(
-                        self,
-                        self::fields::JSXExprContainerField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExprContainer(
-                        self,
-                        self::fields::JSXExprContainerField::Expr,
-                    ));
-                    <JSXExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXExpr as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXFragment {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_fragment`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXFragment {
+    #[doc = "Calls [Visit`::visit_jsx_fragment`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_fragment(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXFragment {
                 span,
@@ -39809,228 +11847,89 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXFragment {
                 closing,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
-                        self,
-                        self::fields::JSXFragmentField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
-                        self,
-                        self::fields::JSXFragmentField::Opening,
-                    ));
-                    <JSXOpeningFragment as VisitWithAstPath<V>>::visit_with_ast_path(
-                        opening,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXOpeningFragment as VisitWith<V>>::visit_with(opening, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
-                        self,
-                        self::fields::JSXFragmentField::Children(usize::MAX),
-                    ));
-                    <Vec<JSXElementChild> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<JSXElementChild> as VisitWith<V>>::visit_with(children, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
-                        self,
-                        self::fields::JSXFragmentField::Closing,
-                    ));
-                    <JSXClosingFragment as VisitWithAstPath<V>>::visit_with_ast_path(
-                        closing,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXClosingFragment as VisitWith<V>>::visit_with(closing, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXMemberExpr {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_member_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_member_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXMemberExpr {
+    #[doc = "Calls [Visit`::visit_jsx_member_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_member_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXMemberExpr { span, obj, prop } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXMemberExpr(
-                        self,
-                        self::fields::JSXMemberExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXMemberExpr(
-                        self,
-                        self::fields::JSXMemberExprField::Obj,
-                    ));
-                    <JSXObject as VisitWithAstPath<V>>::visit_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXObject as VisitWith<V>>::visit_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXMemberExpr(
-                        self,
-                        self::fields::JSXMemberExprField::Prop,
-                    ));
-                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitWith<V>>::visit_with(prop, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXNamespacedName {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_namespaced_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_namespaced_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXNamespacedName {
+    #[doc = "Calls [Visit`::visit_jsx_namespaced_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_namespaced_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXNamespacedName { span, ns, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXNamespacedName(
-                            self,
-                            self::fields::JSXNamespacedNameField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXNamespacedName(
-                            self,
-                            self::fields::JSXNamespacedNameField::Ns,
-                        ));
-                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ns,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitWith<V>>::visit_with(ns, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXNamespacedName(
-                            self,
-                            self::fields::JSXNamespacedNameField::Name,
-                        ));
-                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXObject {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_object`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_object(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXObject {
+    #[doc = "Calls [Visit`::visit_jsx_object`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_object(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXObject::JSXMemberExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXObject(
-                    self,
-                    self::fields::JSXObjectField::JsxmemberExpr,
-                ));
-                <Box<JSXMemberExpr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXMemberExpr> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             JSXObject::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXObject(
-                    self,
-                    self::fields::JSXObjectField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXOpeningElement {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_opening_element`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_opening_element(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXOpeningElement {
+    #[doc = "Calls [Visit`::visit_jsx_opening_element`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_opening_element(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXOpeningElement {
                 name,
@@ -40040,653 +11939,270 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXOpeningElement {
                 type_args,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
-                            self,
-                            self::fields::JSXOpeningElementField::Name,
-                        ));
-                    <JSXElementName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXElementName as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
-                            self,
-                            self::fields::JSXOpeningElementField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
-                            self,
-                            self::fields::JSXOpeningElementField::Attrs(usize::MAX),
-                        ));
-                    <Vec<JSXAttrOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        attrs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<JSXAttrOrSpread> as VisitWith<V>>::visit_with(attrs, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
-                            self,
-                            self::fields::JSXOpeningElementField::TypeArgs,
-                        ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXOpeningFragment {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_opening_fragment`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_opening_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXOpeningFragment {
+    #[doc = "Calls [Visit`::visit_jsx_opening_fragment`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_opening_fragment(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXOpeningFragment { span } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningFragment(
-                            self,
-                            self::fields::JSXOpeningFragmentField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXSpreadChild {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_spread_child`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_spread_child(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXSpreadChild {
+    #[doc = "Calls [Visit`::visit_jsx_spread_child`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_spread_child(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXSpreadChild { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXSpreadChild(
-                        self,
-                        self::fields::JSXSpreadChildField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXSpreadChild(
-                        self,
-                        self::fields::JSXSpreadChildField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXText {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_text`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_text(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for JSXText {
+    #[doc = "Calls [Visit`::visit_jsx_text`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_text(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             JSXText { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXText(
-                        self,
-                        self::fields::JSXTextField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXText(
-                        self,
-                        self::fields::JSXTextField::Value,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXText(
-                        self,
-                        self::fields::JSXTextField::Raw,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Key {
-    #[doc = "Calls [VisitAstPath`::visit_key`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_key(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Key {
+    #[doc = "Calls [Visit`::visit_key`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_key(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Key::Private { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Key(self, self::fields::KeyField::Private));
-                <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Key::Public { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Key(self, self::fields::KeyField::Public));
-                <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PropName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyValuePatProp {
-    #[doc = "Calls [VisitAstPath`::visit_key_value_pat_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_key_value_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for KeyValuePatProp {
+    #[doc = "Calls [Visit`::visit_key_value_pat_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_key_value_pat_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             KeyValuePatProp { key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValuePatProp(
-                        self,
-                        self::fields::KeyValuePatPropField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValuePatProp(
-                        self,
-                        self::fields::KeyValuePatPropField::Value,
-                    ));
-                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyValueProp {
-    #[doc = "Calls [VisitAstPath`::visit_key_value_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_key_value_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for KeyValueProp {
+    #[doc = "Calls [Visit`::visit_key_value_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_key_value_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             KeyValueProp { key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValueProp(
-                        self,
-                        self::fields::KeyValuePropField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValueProp(
-                        self,
-                        self::fields::KeyValuePropField::Value,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LabeledStmt {
-    #[doc = "Calls [VisitAstPath`::visit_labeled_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_labeled_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for LabeledStmt {
+    #[doc = "Calls [Visit`::visit_labeled_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_labeled_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             LabeledStmt { span, label, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LabeledStmt(
-                        self,
-                        self::fields::LabeledStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LabeledStmt(
-                        self,
-                        self::fields::LabeledStmtField::Label,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(label, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LabeledStmt(
-                        self,
-                        self::fields::LabeledStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Lit {
-    #[doc = "Calls [VisitAstPath`::visit_lit`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Lit {
+    #[doc = "Calls [Visit`::visit_lit`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_lit(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Lit::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Str));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Lit::Bool { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Bool));
-                <Bool as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Bool as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Lit::Null { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Null));
-                <Null as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Null as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Lit::Num { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Num));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Lit::BigInt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::BigInt));
-                <BigInt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BigInt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Lit::Regex { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Regex));
-                <Regex as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Regex as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Lit::JSXText { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Jsxtext));
-                <JSXText as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXText as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MemberExpr {
-    #[doc = "Calls [VisitAstPath`::visit_member_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_member_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MemberExpr {
+    #[doc = "Calls [Visit`::visit_member_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_member_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MemberExpr { span, obj, prop } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberExpr(
-                        self,
-                        self::fields::MemberExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberExpr(
-                        self,
-                        self::fields::MemberExprField::Obj,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberExpr(
-                        self,
-                        self::fields::MemberExprField::Prop,
-                    ));
-                    <MemberProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MemberProp as VisitWith<V>>::visit_with(prop, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MemberProp {
-    #[doc = "Calls [VisitAstPath`::visit_member_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_member_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MemberProp {
+    #[doc = "Calls [Visit`::visit_member_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_member_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MemberProp::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberProp(
-                    self,
-                    self::fields::MemberPropField::Ident,
-                ));
-                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MemberProp::PrivateName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberProp(
-                    self,
-                    self::fields::MemberPropField::PrivateName,
-                ));
-                <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             MemberProp::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberProp(
-                    self,
-                    self::fields::MemberPropField::Computed,
-                ));
-                <ComputedPropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComputedPropName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MetaPropExpr {
-    #[doc = "Calls [VisitAstPath`::visit_meta_prop_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_meta_prop_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MetaPropExpr {
+    #[doc = "Calls [Visit`::visit_meta_prop_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_meta_prop_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MetaPropExpr { span, kind } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MetaPropExpr(
-                        self,
-                        self::fields::MetaPropExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MetaPropExpr(
-                        self,
-                        self::fields::MetaPropExprField::Kind,
-                    ));
-                    <MetaPropKind as VisitWithAstPath<V>>::visit_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MetaPropKind as VisitWith<V>>::visit_with(kind, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MetaPropKind {
-    #[doc = "Calls [VisitAstPath`::visit_meta_prop_kind`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_meta_prop_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MetaPropKind {
+    #[doc = "Calls [Visit`::visit_meta_prop_kind`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_meta_prop_kind(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MetaPropKind::NewTarget => {}
             MetaPropKind::ImportMeta => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MethodKind {
-    #[doc = "Calls [VisitAstPath`::visit_method_kind`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_method_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MethodKind {
+    #[doc = "Calls [Visit`::visit_method_kind`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_method_kind(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MethodKind::Method => {}
             MethodKind::Getter => {}
@@ -40694,68 +12210,32 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MethodKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MethodProp {
-    #[doc = "Calls [VisitAstPath`::visit_method_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_method_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for MethodProp {
+    #[doc = "Calls [Visit`::visit_method_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_method_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             MethodProp { key, function } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MethodProp(
-                        self,
-                        self::fields::MethodPropField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MethodProp(
-                        self,
-                        self::fields::MethodPropField::Function,
-                    ));
-                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Module {
-    #[doc = "Calls [VisitAstPath`::visit_module`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Module {
+    #[doc = "Calls [Visit`::visit_module`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_module(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Module {
                 span,
@@ -40763,265 +12243,97 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Module {
                 shebang,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Module(
-                        self,
-                        self::fields::ModuleField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Module(
-                        self,
-                        self::fields::ModuleField::Body(usize::MAX),
-                    ));
-                    <Vec<ModuleItem> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ModuleItem> as VisitWith<V>>::visit_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Module(
-                        self,
-                        self::fields::ModuleField::Shebang,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        shebang,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(shebang, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ModuleDecl {
-    #[doc = "Calls [VisitAstPath`::visit_module_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ModuleDecl {
+    #[doc = "Calls [Visit`::visit_module_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_module_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ModuleDecl::Import { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::Import,
-                ));
-                <ImportDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::ExportDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::ExportDecl,
-                ));
-                <ExportDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::ExportNamed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::ExportNamed,
-                ));
-                <NamedExport as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NamedExport as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::ExportDefaultDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::ExportDefaultDecl,
-                ));
-                <ExportDefaultDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDefaultDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::ExportDefaultExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::ExportDefaultExpr,
-                ));
-                <ExportDefaultExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDefaultExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::ExportAll { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::ExportAll,
-                ));
-                <ExportAll as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportAll as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::TsImportEquals { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::TsImportEquals,
-                ));
-                <Box<TsImportEqualsDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsImportEqualsDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::TsExportAssignment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::TsExportAssignment,
-                ));
-                <TsExportAssignment as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsExportAssignment as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleDecl::TsNamespaceExport { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
-                    self,
-                    self::fields::ModuleDeclField::TsNamespaceExport,
-                ));
-                <TsNamespaceExportDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNamespaceExportDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ModuleExportName {
-    #[doc = "Calls [VisitAstPath`::visit_module_export_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_export_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ModuleExportName {
+    #[doc = "Calls [Visit`::visit_module_export_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_module_export_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ModuleExportName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleExportName(
-                    self,
-                    self::fields::ModuleExportNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleExportName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleExportName(
-                    self,
-                    self::fields::ModuleExportNameField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ModuleItem {
-    #[doc = "Calls [VisitAstPath`::visit_module_item`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_item(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ModuleItem {
+    #[doc = "Calls [Visit`::visit_module_item`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_module_item(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ModuleItem::ModuleDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleItem(
-                    self,
-                    self::fields::ModuleItemField::ModuleDecl,
-                ));
-                <ModuleDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ModuleDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ModuleItem::Stmt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleItem(
-                    self,
-                    self::fields::ModuleItemField::Stmt,
-                ));
-                <Stmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Stmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamedExport {
-    #[doc = "Calls [VisitAstPath`::visit_named_export`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_named_export(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NamedExport {
+    #[doc = "Calls [Visit`::visit_named_export`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_named_export(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NamedExport {
                 span,
@@ -41031,70 +12343,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamedExport {
                 with,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
-                        self,
-                        self::fields::NamedExportField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
-                        self,
-                        self::fields::NamedExportField::Specifiers(usize::MAX),
-                    ));
-                    <Vec<ExportSpecifier> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        specifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ExportSpecifier> as VisitWith<V>>::visit_with(specifiers, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
-                        self,
-                        self::fields::NamedExportField::Src,
-                    ));
-                    <Option<Box<Str>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Str>> as VisitWith<V>>::visit_with(src, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
-                        self,
-                        self::fields::NamedExportField::With,
-                    ));
-                    <Option<Box<ObjectLit>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ObjectLit>> as VisitWith<V>>::visit_with(with, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NewExpr {
-    #[doc = "Calls [VisitAstPath`::visit_new_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_new_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for NewExpr {
+    #[doc = "Calls [Visit`::visit_new_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_new_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             NewExpr {
                 span,
@@ -41104,199 +12374,87 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NewExpr {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
-                        self,
-                        self::fields::NewExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
-                        self,
-                        self::fields::NewExprField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
-                        self,
-                        self::fields::NewExprField::Callee,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(callee, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
-                        self,
-                        self::fields::NewExprField::Args(usize::MAX),
-                    ));
-                    <Option<Vec<ExprOrSpread>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Vec<ExprOrSpread>> as VisitWith<V>>::visit_with(args, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
-                        self,
-                        self::fields::NewExprField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Null {
-    #[doc = "Calls [VisitAstPath`::visit_null`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_null(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Null {
+    #[doc = "Calls [Visit`::visit_null`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_null(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Null { span } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Null(self, self::fields::NullField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Number {
-    #[doc = "Calls [VisitAstPath`::visit_number`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_number(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Number {
+    #[doc = "Calls [Visit`::visit_number`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_number(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Number { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
-                        self,
-                        self::fields::NumberField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
-                        self,
-                        self::fields::NumberField::Raw,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ObjectLit {
-    #[doc = "Calls [VisitAstPath`::visit_object_lit`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ObjectLit {
+    #[doc = "Calls [Visit`::visit_object_lit`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_object_lit(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ObjectLit { span, props } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectLit(
-                        self,
-                        self::fields::ObjectLitField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectLit(
-                        self,
-                        self::fields::ObjectLitField::Props(usize::MAX),
-                    ));
-                    <Vec<PropOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        props,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<PropOrSpread> as VisitWith<V>>::visit_with(props, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ObjectPat {
-    #[doc = "Calls [VisitAstPath`::visit_object_pat`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ObjectPat {
+    #[doc = "Calls [Visit`::visit_object_pat`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_object_pat(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ObjectPat {
                 span,
@@ -41305,113 +12463,45 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ObjectPat {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPat(
-                        self,
-                        self::fields::ObjectPatField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPat(
-                        self,
-                        self::fields::ObjectPatField::Props(usize::MAX),
-                    ));
-                    <Vec<ObjectPatProp> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        props,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ObjectPatProp> as VisitWith<V>>::visit_with(props, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPat(
-                        self,
-                        self::fields::ObjectPatField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ObjectPatProp {
-    #[doc = "Calls [VisitAstPath`::visit_object_pat_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ObjectPatProp {
+    #[doc = "Calls [Visit`::visit_object_pat_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_object_pat_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ObjectPatProp::KeyValue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPatProp(
-                    self,
-                    self::fields::ObjectPatPropField::KeyValue,
-                ));
-                <KeyValuePatProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <KeyValuePatProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ObjectPatProp::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPatProp(
-                    self,
-                    self::fields::ObjectPatPropField::Assign,
-                ));
-                <AssignPatProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignPatProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ObjectPatProp::Rest { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPatProp(
-                    self,
-                    self::fields::ObjectPatPropField::Rest,
-                ));
-                <RestPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RestPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptCall {
-    #[doc = "Calls [VisitAstPath`::visit_opt_call`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_call(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for OptCall {
+    #[doc = "Calls [Visit`::visit_opt_call`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_call(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             OptCall {
                 span,
@@ -41421,120 +12511,50 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptCall {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
-                        self,
-                        self::fields::OptCallField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
-                        self,
-                        self::fields::OptCallField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
-                        self,
-                        self::fields::OptCallField::Callee,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(callee, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
-                        self,
-                        self::fields::OptCallField::Args(usize::MAX),
-                    ));
-                    <Vec<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ExprOrSpread> as VisitWith<V>>::visit_with(args, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
-                        self,
-                        self::fields::OptCallField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptChainBase {
-    #[doc = "Calls [VisitAstPath`::visit_opt_chain_base`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_chain_base(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for OptChainBase {
+    #[doc = "Calls [Visit`::visit_opt_chain_base`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_chain_base(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             OptChainBase::Member { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainBase(
-                    self,
-                    self::fields::OptChainBaseField::Member,
-                ));
-                <MemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             OptChainBase::Call { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainBase(
-                    self,
-                    self::fields::OptChainBaseField::Call,
-                ));
-                <OptCall as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <OptCall as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptChainExpr {
-    #[doc = "Calls [VisitAstPath`::visit_opt_chain_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_chain_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for OptChainExpr {
+    #[doc = "Calls [Visit`::visit_opt_chain_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_chain_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             OptChainExpr {
                 span,
@@ -41542,48 +12562,22 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptChainExpr {
                 base,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainExpr(
-                        self,
-                        self::fields::OptChainExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainExpr(
-                        self,
-                        self::fields::OptChainExprField::Base,
-                    ));
-                    <Box<OptChainBase> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        base,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<OptChainBase> as VisitWith<V>>::visit_with(base, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Param {
-    #[doc = "Calls [VisitAstPath`::visit_param`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_param(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Param {
+    #[doc = "Calls [Visit`::visit_param`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_param(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Param {
                 span,
@@ -41591,229 +12585,93 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Param {
                 pat,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Param(
-                        self,
-                        self::fields::ParamField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Param(
-                        self,
-                        self::fields::ParamField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Param(self, self::fields::ParamField::Pat));
-                    <Pat as VisitWithAstPath<V>>::visit_with_ast_path(
-                        pat,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Pat as VisitWith<V>>::visit_with(pat, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ParamOrTsParamProp {
-    #[doc = "Calls [VisitAstPath`::visit_param_or_ts_param_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_param_or_ts_param_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ParamOrTsParamProp {
+    #[doc = "Calls [Visit`::visit_param_or_ts_param_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_param_or_ts_param_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ParamOrTsParamProp::TsParamProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParamOrTsParamProp(
-                    self,
-                    self::fields::ParamOrTsParamPropField::TsParamProp,
-                ));
-                <TsParamProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsParamProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             ParamOrTsParamProp::Param { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParamOrTsParamProp(
-                    self,
-                    self::fields::ParamOrTsParamPropField::Param,
-                ));
-                <Param as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Param as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ParenExpr {
-    #[doc = "Calls [VisitAstPath`::visit_paren_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_paren_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ParenExpr {
+    #[doc = "Calls [Visit`::visit_paren_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_paren_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ParenExpr { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParenExpr(
-                        self,
-                        self::fields::ParenExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParenExpr(
-                        self,
-                        self::fields::ParenExprField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Pat {
-    #[doc = "Calls [VisitAstPath`::visit_pat`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Pat {
+    #[doc = "Calls [Visit`::visit_pat`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pat(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Pat::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Ident));
-                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Pat::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Array));
-                <ArrayPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Pat::Rest { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Rest));
-                <RestPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RestPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Pat::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Object));
-                <ObjectPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Pat::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Assign));
-                <AssignPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Pat::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Invalid));
-                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Pat::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Expr));
-                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateMethod {
-    #[doc = "Calls [VisitAstPath`::visit_private_method`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_method(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PrivateMethod {
+    #[doc = "Calls [Visit`::visit_private_method`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_private_method(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PrivateMethod {
                 span,
@@ -41827,126 +12685,50 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateMethod {
                 is_override,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
-                        self,
-                        self::fields::PrivateMethodField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
-                        self,
-                        self::fields::PrivateMethodField::Key,
-                    ));
-                    <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PrivateName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
-                        self,
-                        self::fields::PrivateMethodField::Function,
-                    ));
-                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitWith<V>>::visit_with(function, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
-                        self,
-                        self::fields::PrivateMethodField::Kind,
-                    ));
-                    <MethodKind as VisitWithAstPath<V>>::visit_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MethodKind as VisitWith<V>>::visit_with(kind, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
-                        self,
-                        self::fields::PrivateMethodField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateName {
-    #[doc = "Calls [VisitAstPath`::visit_private_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PrivateName {
+    #[doc = "Calls [Visit`::visit_private_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_private_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PrivateName { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateName(
-                        self,
-                        self::fields::PrivateNameField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateName(
-                        self,
-                        self::fields::PrivateNameField::Name,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateProp {
-    #[doc = "Calls [VisitAstPath`::visit_private_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_private_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PrivateProp {
+    #[doc = "Calls [Visit`::visit_private_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_private_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PrivateProp {
                 span,
@@ -41963,406 +12745,148 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateProp {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
-                        self,
-                        self::fields::PrivatePropField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
-                        self,
-                        self::fields::PrivatePropField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
-                        self,
-                        self::fields::PrivatePropField::Key,
-                    ));
-                    <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PrivateName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
-                        self,
-                        self::fields::PrivatePropField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
-                        self,
-                        self::fields::PrivatePropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
-                        self,
-                        self::fields::PrivatePropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
-                        self,
-                        self::fields::PrivatePropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Program {
-    #[doc = "Calls [VisitAstPath`::visit_program`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_program(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Program {
+    #[doc = "Calls [Visit`::visit_program`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_program(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Program::Module { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Program(
-                    self,
-                    self::fields::ProgramField::Module,
-                ));
-                <Module as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Module as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Program::Script { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Program(
-                    self,
-                    self::fields::ProgramField::Script,
-                ));
-                <Script as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Script as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Prop {
-    #[doc = "Calls [VisitAstPath`::visit_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Prop {
+    #[doc = "Calls [Visit`::visit_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Prop::Shorthand { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
-                    self,
-                    self::fields::PropField::Shorthand,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Prop::KeyValue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
-                    self,
-                    self::fields::PropField::KeyValue,
-                ));
-                <KeyValueProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <KeyValueProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Prop::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
-                    self,
-                    self::fields::PropField::Assign,
-                ));
-                <AssignProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Prop::Getter { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
-                    self,
-                    self::fields::PropField::Getter,
-                ));
-                <GetterProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GetterProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Prop::Setter { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
-                    self,
-                    self::fields::PropField::Setter,
-                ));
-                <SetterProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SetterProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Prop::Method { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
-                    self,
-                    self::fields::PropField::Method,
-                ));
-                <MethodProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MethodProp as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PropName {
-    #[doc = "Calls [VisitAstPath`::visit_prop_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PropName {
+    #[doc = "Calls [Visit`::visit_prop_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_prop_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PropName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
-                    self,
-                    self::fields::PropNameField::Ident,
-                ));
-                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PropName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
-                    self,
-                    self::fields::PropNameField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PropName::Num { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
-                    self,
-                    self::fields::PropNameField::Num,
-                ));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PropName::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
-                    self,
-                    self::fields::PropNameField::Computed,
-                ));
-                <ComputedPropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComputedPropName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PropName::BigInt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
-                    self,
-                    self::fields::PropNameField::BigInt,
-                ));
-                <BigInt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BigInt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PropOrSpread {
-    #[doc = "Calls [VisitAstPath`::visit_prop_or_spread`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for PropOrSpread {
+    #[doc = "Calls [Visit`::visit_prop_or_spread`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_prop_or_spread(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             PropOrSpread::Spread { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropOrSpread(
-                    self,
-                    self::fields::PropOrSpreadField::Spread,
-                ));
-                <SpreadElement as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SpreadElement as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             PropOrSpread::Prop { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropOrSpread(
-                    self,
-                    self::fields::PropOrSpreadField::Prop,
-                ));
-                <Box<Prop> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Prop> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Regex {
-    #[doc = "Calls [VisitAstPath`::visit_regex`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_regex(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Regex {
+    #[doc = "Calls [Visit`::visit_regex`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_regex(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Regex { span, exp, flags } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Regex(
-                        self,
-                        self::fields::RegexField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Regex(self, self::fields::RegexField::Exp));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        exp,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(exp, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Regex(
-                        self,
-                        self::fields::RegexField::Flags,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        flags,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(flags, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RestPat {
-    #[doc = "Calls [VisitAstPath`::visit_rest_pat`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_rest_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for RestPat {
+    #[doc = "Calls [Visit`::visit_rest_pat`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_rest_pat(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             RestPat {
                 span,
@@ -42371,115 +12895,47 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RestPat {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
-                        self,
-                        self::fields::RestPatField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
-                        self,
-                        self::fields::RestPatField::Dot3Token,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        dot3_token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(dot3_token, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
-                        self,
-                        self::fields::RestPatField::Arg,
-                    ));
-                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitWith<V>>::visit_with(arg, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
-                        self,
-                        self::fields::RestPatField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ReturnStmt {
-    #[doc = "Calls [VisitAstPath`::visit_return_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_return_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ReturnStmt {
+    #[doc = "Calls [Visit`::visit_return_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_return_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ReturnStmt { span, arg } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ReturnStmt(
-                        self,
-                        self::fields::ReturnStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ReturnStmt(
-                        self,
-                        self::fields::ReturnStmtField::Arg,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Script {
-    #[doc = "Calls [VisitAstPath`::visit_script`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_script(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Script {
+    #[doc = "Calls [Visit`::visit_script`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_script(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Script {
                 span,
@@ -42487,104 +12943,44 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Script {
                 shebang,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Script(
-                        self,
-                        self::fields::ScriptField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Script(
-                        self,
-                        self::fields::ScriptField::Body(usize::MAX),
-                    ));
-                    <Vec<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Script(
-                        self,
-                        self::fields::ScriptField::Shebang,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        shebang,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(shebang, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SeqExpr {
-    #[doc = "Calls [VisitAstPath`::visit_seq_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_seq_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SeqExpr {
+    #[doc = "Calls [Visit`::visit_seq_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_seq_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SeqExpr { span, exprs } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SeqExpr(
-                        self,
-                        self::fields::SeqExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SeqExpr(
-                        self,
-                        self::fields::SeqExprField::Exprs(usize::MAX),
-                    ));
-                    <Vec<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        exprs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<Expr>> as VisitWith<V>>::visit_with(exprs, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SetterProp {
-    #[doc = "Calls [VisitAstPath`::visit_setter_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_setter_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SetterProp {
+    #[doc = "Calls [Visit`::visit_setter_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_setter_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SetterProp {
                 span,
@@ -42594,756 +12990,280 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SetterProp {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
-                        self,
-                        self::fields::SetterPropField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
-                        self,
-                        self::fields::SetterPropField::Key,
-                    ));
-                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
-                        self,
-                        self::fields::SetterPropField::ThisParam,
-                    ));
-                    <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        this_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Pat> as VisitWith<V>>::visit_with(this_param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
-                        self,
-                        self::fields::SetterPropField::Param,
-                    ));
-                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitWith<V>>::visit_with(param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
-                        self,
-                        self::fields::SetterPropField::Body,
-                    ));
-                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SimpleAssignTarget {
-    #[doc = "Calls [VisitAstPath`::visit_simple_assign_target`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_simple_assign_target(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SimpleAssignTarget {
+    #[doc = "Calls [Visit`::visit_simple_assign_target`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_simple_assign_target(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SimpleAssignTarget::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::Ident,
-                ));
-                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::Member { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::Member,
-                ));
-                <MemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MemberExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::SuperProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::SuperProp,
-                ));
-                <SuperPropExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SuperPropExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::Paren { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::Paren,
-                ));
-                <ParenExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ParenExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::OptChain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::OptChain,
-                ));
-                <OptChainExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <OptChainExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsAs { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::TsAs,
-                ));
-                <TsAsExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsAsExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsSatisfies { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::TsSatisfies,
-                ));
-                <TsSatisfiesExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsSatisfiesExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsNonNull { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::TsNonNull,
-                ));
-                <TsNonNullExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNonNullExpr as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsTypeAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::TsTypeAssertion,
-                ));
-                <TsTypeAssertion as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeAssertion as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsInstantiation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::TsInstantiation,
-                ));
-                <TsInstantiation as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-            }
-            SimpleAssignTarget::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
-                    self,
-                    self::fields::SimpleAssignTargetField::Invalid,
-                ));
-                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsInstantiation as VisitWith<V>>::visit_with(_field_0, visitor);
+            }
+            SimpleAssignTarget::Invalid { 0: _field_0 } => {
+                <Invalid as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SpreadElement {
-    #[doc = "Calls [VisitAstPath`::visit_spread_element`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_spread_element(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SpreadElement {
+    #[doc = "Calls [Visit`::visit_spread_element`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_spread_element(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SpreadElement { dot3_token, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SpreadElement(
-                        self,
-                        self::fields::SpreadElementField::Dot3Token,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        dot3_token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(dot3_token, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SpreadElement(
-                        self,
-                        self::fields::SpreadElementField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for StaticBlock {
-    #[doc = "Calls [VisitAstPath`::visit_static_block`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_static_block(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for StaticBlock {
+    #[doc = "Calls [Visit`::visit_static_block`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_static_block(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             StaticBlock { span, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StaticBlock(
-                        self,
-                        self::fields::StaticBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StaticBlock(
-                        self,
-                        self::fields::StaticBlockField::Body,
-                    ));
-                    <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BlockStmt as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Stmt {
-    #[doc = "Calls [VisitAstPath`::visit_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Stmt {
+    #[doc = "Calls [Visit`::visit_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Stmt::Block { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Block));
-                <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BlockStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Empty { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Empty));
-                <EmptyStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <EmptyStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Debugger { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
-                    self,
-                    self::fields::StmtField::Debugger,
-                ));
-                <DebuggerStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DebuggerStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::With { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::With));
-                <WithStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <WithStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Return { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
-                    self,
-                    self::fields::StmtField::Return,
-                ));
-                <ReturnStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ReturnStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Labeled { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
-                    self,
-                    self::fields::StmtField::Labeled,
-                ));
-                <LabeledStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <LabeledStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Break { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Break));
-                <BreakStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BreakStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Continue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
-                    self,
-                    self::fields::StmtField::Continue,
-                ));
-                <ContinueStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContinueStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::If { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::If));
-                <IfStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IfStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Switch { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
-                    self,
-                    self::fields::StmtField::Switch,
-                ));
-                <SwitchStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SwitchStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Throw { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Throw));
-                <ThrowStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ThrowStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Try { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Try));
-                <Box<TryStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TryStmt> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::While { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::While));
-                <WhileStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <WhileStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::DoWhile { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
-                    self,
-                    self::fields::StmtField::DoWhile,
-                ));
-                <DoWhileStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DoWhileStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::For { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::For));
-                <ForStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::ForIn { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::ForIn));
-                <ForInStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForInStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::ForOf { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::ForOf));
-                <ForOfStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForOfStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Decl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Decl));
-                <Decl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Decl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             Stmt::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Expr));
-                <ExprStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExprStmt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Str {
-    #[doc = "Calls [VisitAstPath`::visit_str`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_str(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Str {
+    #[doc = "Calls [Visit`::visit_str`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_str(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Str { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Value));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Raw));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Super {
-    #[doc = "Calls [VisitAstPath`::visit_super`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_super(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Super {
+    #[doc = "Calls [Visit`::visit_super`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_super(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Super { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Super(
-                        self,
-                        self::fields::SuperField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SuperProp {
-    #[doc = "Calls [VisitAstPath`::visit_super_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_super_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SuperProp {
+    #[doc = "Calls [Visit`::visit_super_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_super_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SuperProp::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperProp(
-                    self,
-                    self::fields::SuperPropField::Ident,
-                ));
-                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             SuperProp::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperProp(
-                    self,
-                    self::fields::SuperPropField::Computed,
-                ));
-                <ComputedPropName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComputedPropName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SuperPropExpr {
-    #[doc = "Calls [VisitAstPath`::visit_super_prop_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_super_prop_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SuperPropExpr {
+    #[doc = "Calls [Visit`::visit_super_prop_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_super_prop_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SuperPropExpr { span, obj, prop } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperPropExpr(
-                        self,
-                        self::fields::SuperPropExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperPropExpr(
-                        self,
-                        self::fields::SuperPropExprField::Obj,
-                    ));
-                    <Super as VisitWithAstPath<V>>::visit_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Super as VisitWith<V>>::visit_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperPropExpr(
-                        self,
-                        self::fields::SuperPropExprField::Prop,
-                    ));
-                    <SuperProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SuperProp as VisitWith<V>>::visit_with(prop, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SwitchCase {
-    #[doc = "Calls [VisitAstPath`::visit_switch_case`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_case(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SwitchCase {
+    #[doc = "Calls [Visit`::visit_switch_case`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_switch_case(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SwitchCase { span, test, cons } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchCase(
-                        self,
-                        self::fields::SwitchCaseField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchCase(
-                        self,
-                        self::fields::SwitchCaseField::Test,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchCase(
-                        self,
-                        self::fields::SwitchCaseField::Cons(usize::MAX),
-                    ));
-                    <Vec<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Stmt> as VisitWith<V>>::visit_with(cons, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SwitchStmt {
-    #[doc = "Calls [VisitAstPath`::visit_switch_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for SwitchStmt {
+    #[doc = "Calls [Visit`::visit_switch_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_switch_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             SwitchStmt {
                 span,
@@ -43351,59 +13271,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SwitchStmt {
                 cases,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchStmt(
-                        self,
-                        self::fields::SwitchStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchStmt(
-                        self,
-                        self::fields::SwitchStmtField::Discriminant,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        discriminant,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(discriminant, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchStmt(
-                        self,
-                        self::fields::SwitchStmtField::Cases(usize::MAX),
-                    ));
-                    <Vec<SwitchCase> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        cases,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<SwitchCase> as VisitWith<V>>::visit_with(cases, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TaggedTpl {
-    #[doc = "Calls [VisitAstPath`::visit_tagged_tpl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tagged_tpl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TaggedTpl {
+    #[doc = "Calls [Visit`::visit_tagged_tpl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_tagged_tpl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TaggedTpl {
                 span,
@@ -43413,156 +13299,69 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TaggedTpl {
                 tpl,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
-                        self,
-                        self::fields::TaggedTplField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
-                        self,
-                        self::fields::TaggedTplField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
-                        self,
-                        self::fields::TaggedTplField::Tag,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        tag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
-                        self,
-                        self::fields::TaggedTplField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Box<Expr> as VisitWith<V>>::visit_with(tag, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
-                        self,
-                        self::fields::TaggedTplField::Tpl,
-                    ));
-                    <Box<Tpl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        tpl,
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                {
+                    <Box<Tpl> as VisitWith<V>>::visit_with(tpl, visitor)
+                };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ThisExpr {
-    #[doc = "Calls [VisitAstPath`::visit_this_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_this_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ThisExpr {
+    #[doc = "Calls [Visit`::visit_this_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_this_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ThisExpr { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ThisExpr(
-                        self,
-                        self::fields::ThisExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ThrowStmt {
-    #[doc = "Calls [VisitAstPath`::visit_throw_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_throw_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for ThrowStmt {
+    #[doc = "Calls [Visit`::visit_throw_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_throw_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             ThrowStmt { span, arg } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ThrowStmt(
-                        self,
-                        self::fields::ThrowStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ThrowStmt(
-                        self,
-                        self::fields::ThrowStmtField::Arg,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Tpl {
-    #[doc = "Calls [VisitAstPath`::visit_tpl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tpl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for Tpl {
+    #[doc = "Calls [Visit`::visit_tpl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_tpl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Tpl {
                 span,
@@ -43570,57 +13369,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Tpl {
                 quasis,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentNodeRef::Tpl(self, self::fields::TplField::Span));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Tpl(
-                        self,
-                        self::fields::TplField::Exprs(usize::MAX),
-                    ));
-                    <Vec<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        exprs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<Expr>> as VisitWith<V>>::visit_with(exprs, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Tpl(
-                        self,
-                        self::fields::TplField::Quasis(usize::MAX),
-                    ));
-                    <Vec<TplElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        quasis,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TplElement> as VisitWith<V>>::visit_with(quasis, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TplElement {
-    #[doc = "Calls [VisitAstPath`::visit_tpl_element`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tpl_element(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TplElement {
+    #[doc = "Calls [Visit`::visit_tpl_element`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_tpl_element(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TplElement {
                 span,
@@ -43629,59 +13396,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TplElement {
                 raw,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TplElement(
-                        self,
-                        self::fields::TplElementField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TplElement(
-                        self,
-                        self::fields::TplElementField::Cooked,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        cooked,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitWith<V>>::visit_with(cooked, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TplElement(
-                        self,
-                        self::fields::TplElementField::Raw,
-                    ));
-                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitWith<V>>::visit_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TruePlusMinus {
-    #[doc = "Calls [VisitAstPath`::visit_true_plus_minus`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_true_plus_minus(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TruePlusMinus {
+    #[doc = "Calls [Visit`::visit_true_plus_minus`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_true_plus_minus(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TruePlusMinus::True => {}
             TruePlusMinus::Plus => {}
@@ -43689,23 +13422,13 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TruePlusMinus {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TryStmt {
-    #[doc = "Calls [VisitAstPath`::visit_try_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_try_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TryStmt {
+    #[doc = "Calls [Visit`::visit_try_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_try_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TryStmt {
                 span,
@@ -43714,115 +13437,47 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TryStmt {
                 finalizer,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
-                        self,
-                        self::fields::TryStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
-                        self,
-                        self::fields::TryStmtField::Block,
-                    ));
-                    <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BlockStmt as VisitWith<V>>::visit_with(block, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
-                        self,
-                        self::fields::TryStmtField::Handler,
-                    ));
-                    <Option<CatchClause> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        handler,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<CatchClause> as VisitWith<V>>::visit_with(handler, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
-                        self,
-                        self::fields::TryStmtField::Finalizer,
-                    ));
-                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        finalizer,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitWith<V>>::visit_with(finalizer, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsArrayType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_array_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_array_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsArrayType {
+    #[doc = "Calls [Visit`::visit_ts_array_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_array_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsArrayType { span, elem_type } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsArrayType(
-                        self,
-                        self::fields::TsArrayTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsArrayType(
-                        self,
-                        self::fields::TsArrayTypeField::ElemType,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        elem_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(elem_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsAsExpr {
-    #[doc = "Calls [VisitAstPath`::visit_ts_as_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_as_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsAsExpr {
+    #[doc = "Calls [Visit`::visit_ts_as_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_as_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsAsExpr {
                 span,
@@ -43830,59 +13485,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsAsExpr {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsAsExpr(
-                        self,
-                        self::fields::TsAsExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsAsExpr(
-                        self,
-                        self::fields::TsAsExprField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsAsExpr(
-                        self,
-                        self::fields::TsAsExprField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsCallSignatureDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_call_signature_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_call_signature_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsCallSignatureDecl {
+    #[doc = "Calls [Visit`::visit_ts_call_signature_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_call_signature_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsCallSignatureDecl {
                 span,
@@ -43891,74 +13512,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsCallSignatureDecl {
                 type_params,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
-                            self,
-                            self::fields::TsCallSignatureDeclField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
-                            self,
-                            self::fields::TsCallSignatureDeclField::Params(usize::MAX),
-                        ));
-                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
-                            self,
-                            self::fields::TsCallSignatureDeclField::TypeAnn,
-                        ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
-                            self,
-                            self::fields::TsCallSignatureDeclField::TypeParams,
-                        ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConditionalType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_conditional_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_conditional_type(visitor, self, __ast_path)
-    }
-
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+impl<V: ?Sized + Visit> VisitWith<V> for TsConditionalType {
+    #[doc = "Calls [Visit`::visit_ts_conditional_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_conditional_type(visitor, self)
+    }
+
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsConditionalType {
                 span,
@@ -43968,131 +13543,50 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConditionalType {
                 false_type,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
-                            self,
-                            self::fields::TsConditionalTypeField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
-                            self,
-                            self::fields::TsConditionalTypeField::CheckType,
-                        ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        check_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(check_type, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
-                            self,
-                            self::fields::TsConditionalTypeField::ExtendsType,
-                        ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        extends_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(extends_type, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
-                            self,
-                            self::fields::TsConditionalTypeField::TrueType,
-                        ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        true_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(true_type, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
-                            self,
-                            self::fields::TsConditionalTypeField::FalseType,
-                        ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        false_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(false_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstAssertion {
-    #[doc = "Calls [VisitAstPath`::visit_ts_const_assertion`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_const_assertion(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsConstAssertion {
+    #[doc = "Calls [Visit`::visit_ts_const_assertion`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_const_assertion(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsConstAssertion { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsConstAssertion(
-                        self,
-                        self::fields::TsConstAssertionField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsConstAssertion(
-                        self,
-                        self::fields::TsConstAssertionField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstructSignatureDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_construct_signature_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_construct_signature_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsConstructSignatureDecl {
+    #[doc = "Calls [Visit`::visit_ts_construct_signature_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_construct_signature_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsConstructSignatureDecl {
                 span,
@@ -44101,74 +13595,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstructSignatureDecl
                 type_params,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
-                            self,
-                            self::fields::TsConstructSignatureDeclField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
-                            self,
-                            self::fields::TsConstructSignatureDeclField::Params(usize::MAX),
-                        ));
-                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
-                            self,
-                            self::fields::TsConstructSignatureDeclField::TypeAnn,
-                        ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
-                            self,
-                            self::fields::TsConstructSignatureDeclField::TypeParams,
-                        ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstructorType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_constructor_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_constructor_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsConstructorType {
+    #[doc = "Calls [Visit`::visit_ts_constructor_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_constructor_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsConstructorType {
                 span,
@@ -44178,117 +13626,45 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstructorType {
                 is_abstract,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
-                            self,
-                            self::fields::TsConstructorTypeField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
-                            self,
-                            self::fields::TsConstructorTypeField::Params(usize::MAX),
-                        ));
-                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
-                            self,
-                            self::fields::TsConstructorTypeField::TypeParams,
-                        ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
-                            self,
-                            self::fields::TsConstructorTypeField::TypeAnn,
-                        ));
-                    <Box<TsTypeAnn> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsTypeAnn> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEntityName {
-    #[doc = "Calls [VisitAstPath`::visit_ts_entity_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_entity_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsEntityName {
+    #[doc = "Calls [Visit`::visit_ts_entity_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_entity_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsEntityName::TsQualifiedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEntityName(
-                    self,
-                    self::fields::TsEntityNameField::TsQualifiedName,
-                ));
-                <Box<TsQualifiedName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsQualifiedName> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsEntityName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEntityName(
-                    self,
-                    self::fields::TsEntityNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEnumDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_enum_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsEnumDecl {
+    #[doc = "Calls [Visit`::visit_ts_enum_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_enum_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsEnumDecl {
                 span,
@@ -44298,205 +13674,83 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEnumDecl {
                 members,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumDecl(
-                        self,
-                        self::fields::TsEnumDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumDecl(
-                        self,
-                        self::fields::TsEnumDeclField::Id,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumDecl(
-                        self,
-                        self::fields::TsEnumDeclField::Members(usize::MAX),
-                    ));
-                    <Vec<TsEnumMember> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        members,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsEnumMember> as VisitWith<V>>::visit_with(members, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEnumMember {
-    #[doc = "Calls [VisitAstPath`::visit_ts_enum_member`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_member(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsEnumMember {
+    #[doc = "Calls [Visit`::visit_ts_enum_member`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_enum_member(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsEnumMember { span, id, init } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMember(
-                        self,
-                        self::fields::TsEnumMemberField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMember(
-                        self,
-                        self::fields::TsEnumMemberField::Id,
-                    ));
-                    <TsEnumMemberId as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsEnumMemberId as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMember(
-                        self,
-                        self::fields::TsEnumMemberField::Init,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(init, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEnumMemberId {
-    #[doc = "Calls [VisitAstPath`::visit_ts_enum_member_id`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_member_id(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsEnumMemberId {
+    #[doc = "Calls [Visit`::visit_ts_enum_member_id`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_enum_member_id(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsEnumMemberId::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMemberId(
-                    self,
-                    self::fields::TsEnumMemberIdField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsEnumMemberId::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMemberId(
-                    self,
-                    self::fields::TsEnumMemberIdField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsExportAssignment {
-    #[doc = "Calls [VisitAstPath`::visit_ts_export_assignment`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_export_assignment(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsExportAssignment {
+    #[doc = "Calls [Visit`::visit_ts_export_assignment`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_export_assignment(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsExportAssignment { span, expr } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsExportAssignment(
-                            self,
-                            self::fields::TsExportAssignmentField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsExportAssignment(
-                            self,
-                            self::fields::TsExportAssignmentField::Expr,
-                        ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsExprWithTypeArgs {
-    #[doc = "Calls [VisitAstPath`::visit_ts_expr_with_type_args`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_expr_with_type_args(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsExprWithTypeArgs {
+    #[doc = "Calls [Visit`::visit_ts_expr_with_type_args`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_expr_with_type_args(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsExprWithTypeArgs {
                 span,
@@ -44504,215 +13758,86 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsExprWithTypeArgs {
                 type_args,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsExprWithTypeArgs(
-                            self,
-                            self::fields::TsExprWithTypeArgsField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsExprWithTypeArgs(
-                            self,
-                            self::fields::TsExprWithTypeArgsField::Expr,
-                        ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsExprWithTypeArgs(
-                            self,
-                            self::fields::TsExprWithTypeArgsField::TypeArgs,
-                        ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsExternalModuleRef {
-    #[doc = "Calls [VisitAstPath`::visit_ts_external_module_ref`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_external_module_ref(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsExternalModuleRef {
+    #[doc = "Calls [Visit`::visit_ts_external_module_ref`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_external_module_ref(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsExternalModuleRef { span, expr } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsExternalModuleRef(
-                            self,
-                            self::fields::TsExternalModuleRefField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsExternalModuleRef(
-                            self,
-                            self::fields::TsExternalModuleRefField::Expr,
-                        ));
-                    <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Str as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsFnOrConstructorType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_fn_or_constructor_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_or_constructor_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsFnOrConstructorType {
+    #[doc = "Calls [Visit`::visit_ts_fn_or_constructor_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_fn_or_constructor_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsFnOrConstructorType::TsFnType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::TsFnOrConstructorType(
-                        self,
-                        self::fields::TsFnOrConstructorTypeField::TsFnType,
-                    ));
-                <TsFnType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsFnType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsFnOrConstructorType::TsConstructorType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::TsFnOrConstructorType(
-                        self,
-                        self::fields::TsFnOrConstructorTypeField::TsConstructorType,
-                    ));
-                <TsConstructorType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConstructorType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsFnParam {
-    #[doc = "Calls [VisitAstPath`::visit_ts_fn_param`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_param(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsFnParam {
+    #[doc = "Calls [Visit`::visit_ts_fn_param`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_fn_param(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsFnParam::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
-                    self,
-                    self::fields::TsFnParamField::Ident,
-                ));
-                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsFnParam::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
-                    self,
-                    self::fields::TsFnParamField::Array,
-                ));
-                <ArrayPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsFnParam::Rest { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
-                    self,
-                    self::fields::TsFnParamField::Rest,
-                ));
-                <RestPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RestPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsFnParam::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
-                    self,
-                    self::fields::TsFnParamField::Object,
-                ));
-                <ObjectPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsFnType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_fn_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsFnType {
+    #[doc = "Calls [Visit`::visit_ts_fn_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_fn_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsFnType {
                 span,
@@ -44721,70 +13846,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsFnType {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
-                        self,
-                        self::fields::TsFnTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
-                        self,
-                        self::fields::TsFnTypeField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
-                        self,
-                        self::fields::TsFnTypeField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
-                        self,
-                        self::fields::TsFnTypeField::TypeAnn,
-                    ));
-                    <Box<TsTypeAnn> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsTypeAnn> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsGetterSignature {
-    #[doc = "Calls [VisitAstPath`::visit_ts_getter_signature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_getter_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsGetterSignature {
+    #[doc = "Calls [Visit`::visit_ts_getter_signature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_getter_signature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsGetterSignature {
                 span,
@@ -44793,62 +13876,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsGetterSignature {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsGetterSignature(
-                            self,
-                            self::fields::TsGetterSignatureField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsGetterSignature(
-                            self,
-                            self::fields::TsGetterSignatureField::Key,
-                        ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsGetterSignature(
-                            self,
-                            self::fields::TsGetterSignatureField::TypeAnn,
-                        ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsImportEqualsDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_import_equals_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_import_equals_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsImportEqualsDecl {
+    #[doc = "Calls [Visit`::visit_ts_import_equals_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_import_equals_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsImportEqualsDecl {
                 span,
@@ -44858,62 +13904,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsImportEqualsDecl {
                 module_ref,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsImportEqualsDecl(
-                            self,
-                            self::fields::TsImportEqualsDeclField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsImportEqualsDecl(
-                            self,
-                            self::fields::TsImportEqualsDeclField::Id,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsImportEqualsDecl(
-                            self,
-                            self::fields::TsImportEqualsDeclField::ModuleRef,
-                        ));
-                    <TsModuleRef as VisitWithAstPath<V>>::visit_with_ast_path(
-                        module_ref,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsModuleRef as VisitWith<V>>::visit_with(module_ref, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsImportType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_import_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_import_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsImportType {
+    #[doc = "Calls [Visit`::visit_ts_import_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_import_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsImportType {
                 span,
@@ -44922,66 +13931,30 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsImportType {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
-                        self,
-                        self::fields::TsImportTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
-                        self,
-                        self::fields::TsImportTypeField::Arg,
-                    ));
-                    <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Str as VisitWith<V>>::visit_with(arg, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
-                        self,
-                        self::fields::TsImportTypeField::Qualifier,
-                    ));
-                    <Option<TsEntityName> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        qualifier,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TsEntityName> as VisitWith<V>>::visit_with(qualifier, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
-                        self,
-                        self::fields::TsImportTypeField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIndexSignature {
-    #[doc = "Calls [VisitAstPath`::visit_ts_index_signature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_index_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsIndexSignature {
+    #[doc = "Calls [Visit`::visit_ts_index_signature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_index_signature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsIndexSignature {
                 params,
@@ -44991,59 +13964,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIndexSignature {
                 span,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsIndexSignature(
-                        self,
-                        self::fields::TsIndexSignatureField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsIndexSignature(
-                        self,
-                        self::fields::TsIndexSignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsIndexSignature(
-                        self,
-                        self::fields::TsIndexSignatureField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIndexedAccessType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_indexed_access_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_indexed_access_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsIndexedAccessType {
+    #[doc = "Calls [Visit`::visit_ts_indexed_access_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_indexed_access_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsIndexedAccessType {
                 span,
@@ -45052,107 +13991,44 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIndexedAccessType {
                 index_type,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsIndexedAccessType(
-                            self,
-                            self::fields::TsIndexedAccessTypeField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsIndexedAccessType(
-                            self,
-                            self::fields::TsIndexedAccessTypeField::ObjType,
-                        ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        obj_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(obj_type, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsIndexedAccessType(
-                            self,
-                            self::fields::TsIndexedAccessTypeField::IndexType,
-                        ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        index_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(index_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInferType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_infer_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_infer_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsInferType {
+    #[doc = "Calls [Visit`::visit_ts_infer_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_infer_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsInferType { span, type_param } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInferType(
-                        self,
-                        self::fields::TsInferTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInferType(
-                        self,
-                        self::fields::TsInferTypeField::TypeParam,
-                    ));
-                    <TsTypeParam as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeParam as VisitWith<V>>::visit_with(type_param, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInstantiation {
-    #[doc = "Calls [VisitAstPath`::visit_ts_instantiation`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_instantiation(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsInstantiation {
+    #[doc = "Calls [Visit`::visit_ts_instantiation`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_instantiation(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsInstantiation {
                 span,
@@ -45160,104 +14036,44 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInstantiation {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInstantiation(
-                        self,
-                        self::fields::TsInstantiationField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInstantiation(
-                        self,
-                        self::fields::TsInstantiationField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInstantiation(
-                        self,
-                        self::fields::TsInstantiationField::TypeArgs,
-                    ));
-                    <Box<TsTypeParamInstantiation> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsTypeParamInstantiation> as VisitWith<V>>::visit_with(type_args, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInterfaceBody {
-    #[doc = "Calls [VisitAstPath`::visit_ts_interface_body`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_interface_body(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsInterfaceBody {
+    #[doc = "Calls [Visit`::visit_ts_interface_body`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_interface_body(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsInterfaceBody { span, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceBody(
-                        self,
-                        self::fields::TsInterfaceBodyField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceBody(
-                        self,
-                        self::fields::TsInterfaceBodyField::Body(usize::MAX),
-                    ));
-                    <Vec<TsTypeElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTypeElement> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInterfaceDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_interface_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_interface_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsInterfaceDecl {
+    #[doc = "Calls [Visit`::visit_ts_interface_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_interface_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsInterfaceDecl {
                 span,
@@ -45268,173 +14084,69 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInterfaceDecl {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
-                        self,
-                        self::fields::TsInterfaceDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
-                        self,
-                        self::fields::TsInterfaceDeclField::Id,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
-                        self,
-                        self::fields::TsInterfaceDeclField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
-                        self,
-                        self::fields::TsInterfaceDeclField::Extends(usize::MAX),
-                    ));
-                    <Vec<TsExprWithTypeArgs> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        extends,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsExprWithTypeArgs> as VisitWith<V>>::visit_with(extends, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
-                        self,
-                        self::fields::TsInterfaceDeclField::Body,
-                    ));
-                    <TsInterfaceBody as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsInterfaceBody as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIntersectionType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_intersection_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_intersection_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsIntersectionType {
+    #[doc = "Calls [Visit`::visit_ts_intersection_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_intersection_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsIntersectionType { span, types } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsIntersectionType(
-                            self,
-                            self::fields::TsIntersectionTypeField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsIntersectionType(
-                            self,
-                            self::fields::TsIntersectionTypeField::Types(usize::MAX),
-                        ));
-                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(types, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsKeywordType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_keyword_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_keyword_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsKeywordType {
+    #[doc = "Calls [Visit`::visit_ts_keyword_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_keyword_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsKeywordType { span, kind } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsKeywordType(
-                        self,
-                        self::fields::TsKeywordTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsKeywordType(
-                        self,
-                        self::fields::TsKeywordTypeField::Kind,
-                    ));
-                    <TsKeywordTypeKind as VisitWithAstPath<V>>::visit_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsKeywordTypeKind as VisitWith<V>>::visit_with(kind, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsKeywordTypeKind {
-    #[doc = "Calls [VisitAstPath`::visit_ts_keyword_type_kind`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_keyword_type_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsKeywordTypeKind {
+    #[doc = "Calls [Visit`::visit_ts_keyword_type_kind`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_keyword_type_kind(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsKeywordTypeKind::TsAnyKeyword => {}
             TsKeywordTypeKind::TsUnknownKeyword => {}
@@ -45452,140 +14164,58 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsKeywordTypeKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsLit {
-    #[doc = "Calls [VisitAstPath`::visit_ts_lit`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsLit {
+    #[doc = "Calls [Visit`::visit_ts_lit`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_lit(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsLit::Number { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLit(
-                    self,
-                    self::fields::TsLitField::Number,
-                ));
-                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsLit::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::TsLit(self, self::fields::TsLitField::Str));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsLit::Bool { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLit(
-                    self,
-                    self::fields::TsLitField::Bool,
-                ));
-                <Bool as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Bool as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsLit::BigInt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLit(
-                    self,
-                    self::fields::TsLitField::BigInt,
-                ));
-                <BigInt as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BigInt as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsLit::Tpl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentNodeRef::TsLit(self, self::fields::TsLitField::Tpl));
-                <TsTplLitType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTplLitType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsLitType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_lit_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_lit_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsLitType {
+    #[doc = "Calls [Visit`::visit_ts_lit_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_lit_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsLitType { span, lit } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLitType(
-                        self,
-                        self::fields::TsLitTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLitType(
-                        self,
-                        self::fields::TsLitTypeField::Lit,
-                    ));
-                    <TsLit as VisitWithAstPath<V>>::visit_with_ast_path(
-                        lit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsLit as VisitWith<V>>::visit_with(lit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsMappedType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_mapped_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_mapped_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsMappedType {
+    #[doc = "Calls [Visit`::visit_ts_mapped_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_mapped_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsMappedType {
                 span,
@@ -45596,92 +14226,34 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsMappedType {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
-                        self,
-                        self::fields::TsMappedTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
-                        self,
-                        self::fields::TsMappedTypeField::Readonly,
-                    ));
-                    <Option<TruePlusMinus> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        readonly,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TruePlusMinus> as VisitWith<V>>::visit_with(readonly, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
-                        self,
-                        self::fields::TsMappedTypeField::TypeParam,
-                    ));
-                    <TsTypeParam as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeParam as VisitWith<V>>::visit_with(type_param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
-                        self,
-                        self::fields::TsMappedTypeField::NameType,
-                    ));
-                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(name_type, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
-                        self,
-                        self::fields::TsMappedTypeField::Optional,
-                    ));
-                    <Option<TruePlusMinus> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        optional,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TruePlusMinus> as VisitWith<V>>::visit_with(optional, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
-                        self,
-                        self::fields::TsMappedTypeField::TypeAnn,
-                    ));
-                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsMethodSignature {
-    #[doc = "Calls [VisitAstPath`::visit_ts_method_signature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_method_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsMethodSignature {
+    #[doc = "Calls [Visit`::visit_ts_method_signature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_method_signature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsMethodSignature {
                 span,
@@ -45693,131 +14265,50 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsMethodSignature {
                 type_params,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
-                            self,
-                            self::fields::TsMethodSignatureField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
-                            self,
-                            self::fields::TsMethodSignatureField::Key,
-                        ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
-                            self,
-                            self::fields::TsMethodSignatureField::Params(usize::MAX),
-                        ));
-                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitWith<V>>::visit_with(params, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
-                            self,
-                            self::fields::TsMethodSignatureField::TypeAnn,
-                        ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
-                            self,
-                            self::fields::TsMethodSignatureField::TypeParams,
-                        ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleBlock {
-    #[doc = "Calls [VisitAstPath`::visit_ts_module_block`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_block(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsModuleBlock {
+    #[doc = "Calls [Visit`::visit_ts_module_block`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_module_block(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsModuleBlock { span, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleBlock(
-                        self,
-                        self::fields::TsModuleBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleBlock(
-                        self,
-                        self::fields::TsModuleBlockField::Body(usize::MAX),
-                    ));
-                    <Vec<ModuleItem> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ModuleItem> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_module_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsModuleDecl {
+    #[doc = "Calls [Visit`::visit_ts_module_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_module_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsModuleDecl {
                 span,
@@ -45827,188 +14318,76 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleDecl {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleDecl(
-                        self,
-                        self::fields::TsModuleDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleDecl(
-                        self,
-                        self::fields::TsModuleDeclField::Id,
-                    ));
-                    <TsModuleName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsModuleName as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleDecl(
-                        self,
-                        self::fields::TsModuleDeclField::Body,
-                    ));
-                    <Option<TsNamespaceBody> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TsNamespaceBody> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleName {
-    #[doc = "Calls [VisitAstPath`::visit_ts_module_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsModuleName {
+    #[doc = "Calls [Visit`::visit_ts_module_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_module_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsModuleName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleName(
-                    self,
-                    self::fields::TsModuleNameField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsModuleName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleName(
-                    self,
-                    self::fields::TsModuleNameField::Str,
-                ));
-                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleRef {
-    #[doc = "Calls [VisitAstPath`::visit_ts_module_ref`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_module_ref(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsModuleRef {
+    #[doc = "Calls [Visit`::visit_ts_module_ref`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_module_ref(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsModuleRef::TsEntityName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleRef(
-                    self,
-                    self::fields::TsModuleRefField::TsEntityName,
-                ));
-                <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsEntityName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsModuleRef::TsExternalModuleRef { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleRef(
-                    self,
-                    self::fields::TsModuleRefField::TsExternalModuleRef,
-                ));
-                <TsExternalModuleRef as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsExternalModuleRef as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNamespaceBody {
-    #[doc = "Calls [VisitAstPath`::visit_ts_namespace_body`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_body(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsNamespaceBody {
+    #[doc = "Calls [Visit`::visit_ts_namespace_body`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_namespace_body(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsNamespaceBody::TsModuleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceBody(
-                    self,
-                    self::fields::TsNamespaceBodyField::TsModuleBlock,
-                ));
-                <TsModuleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsModuleBlock as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsNamespaceBody::TsNamespaceDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceBody(
-                    self,
-                    self::fields::TsNamespaceBodyField::TsNamespaceDecl,
-                ));
-                <TsNamespaceDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNamespaceDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNamespaceDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_namespace_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsNamespaceDecl {
+    #[doc = "Calls [Visit`::visit_ts_namespace_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_namespace_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsNamespaceDecl {
                 span,
@@ -46018,196 +14397,82 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNamespaceDecl {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceDecl(
-                        self,
-                        self::fields::TsNamespaceDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceDecl(
-                        self,
-                        self::fields::TsNamespaceDeclField::Id,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceDecl(
-                        self,
-                        self::fields::TsNamespaceDeclField::Body,
-                    ));
-                    <Box<TsNamespaceBody> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsNamespaceBody> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNamespaceExportDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_namespace_export_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_namespace_export_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsNamespaceExportDecl {
+    #[doc = "Calls [Visit`::visit_ts_namespace_export_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_namespace_export_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsNamespaceExportDecl { span, id } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsNamespaceExportDecl(
-                            self,
-                            self::fields::TsNamespaceExportDeclField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsNamespaceExportDecl(
-                            self,
-                            self::fields::TsNamespaceExportDeclField::Id,
-                        ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(id, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNonNullExpr {
-    #[doc = "Calls [VisitAstPath`::visit_ts_non_null_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_non_null_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsNonNullExpr {
+    #[doc = "Calls [Visit`::visit_ts_non_null_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_non_null_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsNonNullExpr { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNonNullExpr(
-                        self,
-                        self::fields::TsNonNullExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNonNullExpr(
-                        self,
-                        self::fields::TsNonNullExprField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsOptionalType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_optional_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_optional_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsOptionalType {
+    #[doc = "Calls [Visit`::visit_ts_optional_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_optional_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsOptionalType { span, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsOptionalType(
-                        self,
-                        self::fields::TsOptionalTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsOptionalType(
-                        self,
-                        self::fields::TsOptionalTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsParamProp {
-    #[doc = "Calls [VisitAstPath`::visit_ts_param_prop`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_param_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsParamProp {
+    #[doc = "Calls [Visit`::visit_ts_param_prop`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_param_prop(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsParamProp {
                 span,
@@ -46218,160 +14483,64 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsParamProp {
                 param,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
-                        self,
-                        self::fields::TsParamPropField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
-                        self,
-                        self::fields::TsParamPropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitWith<V>>::visit_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
-                        self,
-                        self::fields::TsParamPropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Accessibility> as VisitWith<V>>::visit_with(accessibility, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
-                        self,
-                        self::fields::TsParamPropField::Param,
-                    ));
-                    <TsParamPropParam as VisitWithAstPath<V>>::visit_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsParamPropParam as VisitWith<V>>::visit_with(param, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsParamPropParam {
-    #[doc = "Calls [VisitAstPath`::visit_ts_param_prop_param`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_param_prop_param(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsParamPropParam {
+    #[doc = "Calls [Visit`::visit_ts_param_prop_param`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_param_prop_param(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsParamPropParam::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamPropParam(
-                    self,
-                    self::fields::TsParamPropParamField::Ident,
-                ));
-                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsParamPropParam::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamPropParam(
-                    self,
-                    self::fields::TsParamPropParamField::Assign,
-                ));
-                <AssignPat as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignPat as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsParenthesizedType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_parenthesized_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_parenthesized_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsParenthesizedType {
+    #[doc = "Calls [Visit`::visit_ts_parenthesized_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_parenthesized_type(visitor, self)
     }
-
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        match self {
-            TsParenthesizedType { span, type_ann } => {
-                {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsParenthesizedType(
-                            self,
-                            self::fields::TsParenthesizedTypeField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+
+    fn visit_children_with(&self, visitor: &mut V) {
+        match self {
+            TsParenthesizedType { span, type_ann } => {
+                {
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsParenthesizedType(
-                            self,
-                            self::fields::TsParenthesizedTypeField::TypeAnn,
-                        ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsPropertySignature {
-    #[doc = "Calls [VisitAstPath`::visit_ts_property_signature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_property_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsPropertySignature {
+    #[doc = "Calls [Visit`::visit_ts_property_signature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_property_signature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsPropertySignature {
                 span,
@@ -46382,163 +14551,66 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsPropertySignature {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsPropertySignature(
-                            self,
-                            self::fields::TsPropertySignatureField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsPropertySignature(
-                            self,
-                            self::fields::TsPropertySignatureField::Key,
-                        ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsPropertySignature(
-                            self,
-                            self::fields::TsPropertySignatureField::TypeAnn,
-                        ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsQualifiedName {
-    #[doc = "Calls [VisitAstPath`::visit_ts_qualified_name`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_qualified_name(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsQualifiedName {
+    #[doc = "Calls [Visit`::visit_ts_qualified_name`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_qualified_name(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsQualifiedName { span, left, right } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsQualifiedName(
-                        self,
-                        self::fields::TsQualifiedNameField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsQualifiedName(
-                        self,
-                        self::fields::TsQualifiedNameField::Left,
-                    ));
-                    <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsEntityName as VisitWith<V>>::visit_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsQualifiedName(
-                        self,
-                        self::fields::TsQualifiedNameField::Right,
-                    ));
-                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitWith<V>>::visit_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsRestType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_rest_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_rest_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsRestType {
+    #[doc = "Calls [Visit`::visit_ts_rest_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_rest_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsRestType { span, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsRestType(
-                        self,
-                        self::fields::TsRestTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsRestType(
-                        self,
-                        self::fields::TsRestTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsSatisfiesExpr {
-    #[doc = "Calls [VisitAstPath`::visit_ts_satisfies_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_satisfies_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsSatisfiesExpr {
+    #[doc = "Calls [Visit`::visit_ts_satisfies_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_satisfies_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsSatisfiesExpr {
                 span,
@@ -46546,59 +14618,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsSatisfiesExpr {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsSatisfiesExpr(
-                        self,
-                        self::fields::TsSatisfiesExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsSatisfiesExpr(
-                        self,
-                        self::fields::TsSatisfiesExprField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsSatisfiesExpr(
-                        self,
-                        self::fields::TsSatisfiesExprField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsSetterSignature {
-    #[doc = "Calls [VisitAstPath`::visit_ts_setter_signature`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_setter_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsSetterSignature {
+    #[doc = "Calls [Visit`::visit_ts_setter_signature`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_setter_signature(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsSetterSignature {
                 span,
@@ -46607,139 +14645,58 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsSetterSignature {
                 param,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsSetterSignature(
-                            self,
-                            self::fields::TsSetterSignatureField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsSetterSignature(
-                            self,
-                            self::fields::TsSetterSignatureField::Key,
-                        ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(key, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsSetterSignature(
-                            self,
-                            self::fields::TsSetterSignatureField::Param,
-                        ));
-                    <TsFnParam as VisitWithAstPath<V>>::visit_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsFnParam as VisitWith<V>>::visit_with(param, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsThisType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_this_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_this_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsThisType {
+    #[doc = "Calls [Visit`::visit_ts_this_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_this_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsThisType { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsThisType(
-                        self,
-                        self::fields::TsThisTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsThisTypeOrIdent {
-    #[doc = "Calls [VisitAstPath`::visit_ts_this_type_or_ident`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_this_type_or_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsThisTypeOrIdent {
+    #[doc = "Calls [Visit`::visit_ts_this_type_or_ident`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_this_type_or_ident(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsThisTypeOrIdent::TsThisType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsThisTypeOrIdent(
-                    self,
-                    self::fields::TsThisTypeOrIdentField::TsThisType,
-                ));
-                <TsThisType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsThisType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsThisTypeOrIdent::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsThisTypeOrIdent(
-                    self,
-                    self::fields::TsThisTypeOrIdentField::Ident,
-                ));
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTplLitType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_tpl_lit_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tpl_lit_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTplLitType {
+    #[doc = "Calls [Visit`::visit_ts_tpl_lit_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_tpl_lit_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTplLitType {
                 span,
@@ -46747,401 +14704,137 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTplLitType {
                 quasis,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTplLitType(
-                        self,
-                        self::fields::TsTplLitTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTplLitType(
-                        self,
-                        self::fields::TsTplLitTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(types, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTplLitType(
-                        self,
-                        self::fields::TsTplLitTypeField::Quasis(usize::MAX),
-                    ));
-                    <Vec<TplElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        quasis,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TplElement> as VisitWith<V>>::visit_with(quasis, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTupleElement {
-    #[doc = "Calls [VisitAstPath`::visit_ts_tuple_element`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_element(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTupleElement {
+    #[doc = "Calls [Visit`::visit_ts_tuple_element`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_tuple_element(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTupleElement { span, label, ty } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleElement(
-                        self,
-                        self::fields::TsTupleElementField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleElement(
-                        self,
-                        self::fields::TsTupleElementField::Label,
-                    ));
-                    <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Pat> as VisitWith<V>>::visit_with(label, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleElement(
-                        self,
-                        self::fields::TsTupleElementField::Ty,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ty,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(ty, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTupleType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_tuple_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTupleType {
+    #[doc = "Calls [Visit`::visit_ts_tuple_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_tuple_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTupleType { span, elem_types } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleType(
-                        self,
-                        self::fields::TsTupleTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleType(
-                        self,
-                        self::fields::TsTupleTypeField::ElemTypes(usize::MAX),
-                    ));
-                    <Vec<TsTupleElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        elem_types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTupleElement> as VisitWith<V>>::visit_with(elem_types, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsType {
+    #[doc = "Calls [Visit`::visit_ts_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsType::TsKeywordType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsKeywordType,
-                ));
-                <TsKeywordType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsKeywordType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsThisType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsThisType,
-                ));
-                <TsThisType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsThisType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsFnOrConstructorType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsFnOrConstructorType,
-                ));
-                <TsFnOrConstructorType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsFnOrConstructorType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsTypeRef { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsTypeRef,
-                ));
-                <TsTypeRef as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeRef as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsTypeQuery { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsTypeQuery,
-                ));
-                <TsTypeQuery as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeQuery as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsTypeLit { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsTypeLit,
-                ));
-                <TsTypeLit as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeLit as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsArrayType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsArrayType,
-                ));
-                <TsArrayType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsArrayType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsTupleType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsTupleType,
-                ));
-                <TsTupleType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTupleType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsOptionalType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsOptionalType,
-                ));
-                <TsOptionalType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsOptionalType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsRestType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsRestType,
-                ));
-                <TsRestType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsRestType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsUnionOrIntersectionType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsUnionOrIntersectionType,
-                ));
-                <TsUnionOrIntersectionType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsUnionOrIntersectionType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsConditionalType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsConditionalType,
-                ));
-                <TsConditionalType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConditionalType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsInferType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsInferType,
-                ));
-                <TsInferType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsInferType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsParenthesizedType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsParenthesizedType,
-                ));
-                <TsParenthesizedType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsParenthesizedType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsTypeOperator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsTypeOperator,
-                ));
-                <TsTypeOperator as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeOperator as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsIndexedAccessType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsIndexedAccessType,
-                ));
-                <TsIndexedAccessType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIndexedAccessType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsMappedType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsMappedType,
-                ));
-                <TsMappedType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsMappedType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsLitType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsLitType,
-                ));
-                <TsLitType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsLitType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsTypePredicate { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsTypePredicate,
-                ));
-                <TsTypePredicate as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypePredicate as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsType::TsImportType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
-                    self,
-                    self::fields::TsTypeField::TsImportType,
-                ));
-                <TsImportType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsImportType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAliasDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_alias_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_alias_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeAliasDecl {
+    #[doc = "Calls [Visit`::visit_ts_type_alias_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_alias_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeAliasDecl {
                 span,
@@ -47151,115 +14844,47 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAliasDecl {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
-                        self,
-                        self::fields::TsTypeAliasDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
-                        self,
-                        self::fields::TsTypeAliasDeclField::Id,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
-                        self,
-                        self::fields::TsTypeAliasDeclField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as VisitWith<V>>::visit_with(type_params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
-                        self,
-                        self::fields::TsTypeAliasDeclField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAnn {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_ann`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_ann(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeAnn {
+    #[doc = "Calls [Visit`::visit_ts_type_ann`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_ann(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeAnn { span, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAnn(
-                        self,
-                        self::fields::TsTypeAnnField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAnn(
-                        self,
-                        self::fields::TsTypeAnnField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAssertion {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_assertion`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_assertion(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeAssertion {
+    #[doc = "Calls [Visit`::visit_ts_type_assertion`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_assertion(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeAssertion {
                 span,
@@ -47267,258 +14892,98 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAssertion {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAssertion(
-                        self,
-                        self::fields::TsTypeAssertionField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAssertion(
-                        self,
-                        self::fields::TsTypeAssertionField::Expr,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAssertion(
-                        self,
-                        self::fields::TsTypeAssertionField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeElement {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_element`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_element(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeElement {
+    #[doc = "Calls [Visit`::visit_ts_type_element`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_element(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeElement::TsCallSignatureDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
-                    self,
-                    self::fields::TsTypeElementField::TsCallSignatureDecl,
-                ));
-                <TsCallSignatureDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsCallSignatureDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsTypeElement::TsConstructSignatureDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
-                    self,
-                    self::fields::TsTypeElementField::TsConstructSignatureDecl,
-                ));
-                <TsConstructSignatureDecl as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConstructSignatureDecl as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsTypeElement::TsPropertySignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
-                    self,
-                    self::fields::TsTypeElementField::TsPropertySignature,
-                ));
-                <TsPropertySignature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsPropertySignature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsTypeElement::TsGetterSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
-                    self,
-                    self::fields::TsTypeElementField::TsGetterSignature,
-                ));
-                <TsGetterSignature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsGetterSignature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsTypeElement::TsSetterSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
-                    self,
-                    self::fields::TsTypeElementField::TsSetterSignature,
-                ));
-                <TsSetterSignature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsSetterSignature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsTypeElement::TsMethodSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
-                    self,
-                    self::fields::TsTypeElementField::TsMethodSignature,
-                ));
-                <TsMethodSignature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsMethodSignature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsTypeElement::TsIndexSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
-                    self,
-                    self::fields::TsTypeElementField::TsIndexSignature,
-                ));
-                <TsIndexSignature as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIndexSignature as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeLit {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_lit`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeLit {
+    #[doc = "Calls [Visit`::visit_ts_type_lit`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_lit(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeLit { span, members } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeLit(
-                        self,
-                        self::fields::TsTypeLitField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeLit(
-                        self,
-                        self::fields::TsTypeLitField::Members(usize::MAX),
-                    ));
-                    <Vec<TsTypeElement> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        members,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTypeElement> as VisitWith<V>>::visit_with(members, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeOperator {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_operator`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeOperator {
+    #[doc = "Calls [Visit`::visit_ts_type_operator`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_operator(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeOperator { span, op, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeOperator(
-                        self,
-                        self::fields::TsTypeOperatorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeOperator(
-                        self,
-                        self::fields::TsTypeOperatorField::Op,
-                    ));
-                    <TsTypeOperatorOp as VisitWithAstPath<V>>::visit_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeOperator(
-                        self,
-                        self::fields::TsTypeOperatorField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeOperatorOp as VisitWith<V>>::visit_with(op, visitor)
+                };
+                {
+                    <Box<TsType> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeOperatorOp {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_operator_op`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_operator_op(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeOperatorOp {
+    #[doc = "Calls [Visit`::visit_ts_type_operator_op`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_operator_op(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeOperatorOp::KeyOf => {}
             TsTypeOperatorOp::Unique => {}
@@ -47526,23 +14991,13 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeOperatorOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeParam {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_param`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeParam {
+    #[doc = "Calls [Visit`::visit_ts_type_param`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_param(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeParam {
                 span,
@@ -47554,162 +15009,66 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeParam {
                 default,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
-                        self,
-                        self::fields::TsTypeParamField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
-                        self,
-                        self::fields::TsTypeParamField::Name,
-                    ));
-                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
-                        self,
-                        self::fields::TsTypeParamField::Constraint,
-                    ));
-                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        constraint,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(constraint, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
-                        self,
-                        self::fields::TsTypeParamField::Default,
-                    ));
-                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        default,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitWith<V>>::visit_with(default, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeParamDecl {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_param_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeParamDecl {
+    #[doc = "Calls [Visit`::visit_ts_type_param_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_param_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeParamDecl { span, params } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParamDecl(
-                        self,
-                        self::fields::TsTypeParamDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParamDecl(
-                        self,
-                        self::fields::TsTypeParamDeclField::Params(usize::MAX),
-                    ));
-                    <Vec<TsTypeParam> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTypeParam> as VisitWith<V>>::visit_with(params, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeParamInstantiation {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_param_instantiation`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_param_instantiation(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeParamInstantiation {
+    #[doc = "Calls [Visit`::visit_ts_type_param_instantiation`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_param_instantiation(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeParamInstantiation { span, params } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsTypeParamInstantiation(
-                            self,
-                            self::fields::TsTypeParamInstantiationField::Span,
-                        ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentNodeRef::TsTypeParamInstantiation(
-                            self,
-                            self::fields::TsTypeParamInstantiationField::Params(usize::MAX),
-                        ));
-                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(params, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypePredicate {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_predicate`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_predicate(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypePredicate {
+    #[doc = "Calls [Visit`::visit_ts_type_predicate`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_predicate(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypePredicate {
                 span,
@@ -47718,59 +15077,25 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypePredicate {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypePredicate(
-                        self,
-                        self::fields::TsTypePredicateField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypePredicate(
-                        self,
-                        self::fields::TsTypePredicateField::ParamName,
-                    ));
-                    <TsThisTypeOrIdent as VisitWithAstPath<V>>::visit_with_ast_path(
-                        param_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsThisTypeOrIdent as VisitWith<V>>::visit_with(param_name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypePredicate(
-                        self,
-                        self::fields::TsTypePredicateField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitWith<V>>::visit_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeQuery {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_query`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_query(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeQuery {
+    #[doc = "Calls [Visit`::visit_ts_type_query`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_query(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeQuery {
                 span,
@@ -47778,98 +15103,44 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeQuery {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQuery(
-                        self,
-                        self::fields::TsTypeQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQuery(
-                        self,
-                        self::fields::TsTypeQueryField::ExprName,
-                    ));
-                    <TsTypeQueryExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                        expr_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeQueryExpr as VisitWith<V>>::visit_with(expr_name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQuery(
-                        self,
-                        self::fields::TsTypeQueryField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeQueryExpr {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_query_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_query_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeQueryExpr {
+    #[doc = "Calls [Visit`::visit_ts_type_query_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_query_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeQueryExpr::TsEntityName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQueryExpr(
-                    self,
-                    self::fields::TsTypeQueryExprField::TsEntityName,
-                ));
-                <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsEntityName as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsTypeQueryExpr::Import { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQueryExpr(
-                    self,
-                    self::fields::TsTypeQueryExprField::Import,
-                ));
-                <TsImportType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsImportType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeRef {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_ref`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_ref(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsTypeRef {
+    #[doc = "Calls [Visit`::visit_ts_type_ref`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_ref(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsTypeRef {
                 span,
@@ -47877,201 +15148,86 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeRef {
                 type_params,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeRef(
-                        self,
-                        self::fields::TsTypeRefField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeRef(
-                        self,
-                        self::fields::TsTypeRefField::TypeName,
-                    ));
-                    <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
-                        type_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsEntityName as VisitWith<V>>::visit_with(type_name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeRef(
-                        self,
-                        self::fields::TsTypeRefField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitWith<V>>::visit_with(
+                        type_params,
+                        visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsUnionOrIntersectionType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_union_or_intersection_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_union_or_intersection_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsUnionOrIntersectionType {
+    #[doc = "Calls [Visit`::visit_ts_union_or_intersection_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_union_or_intersection_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsUnionOrIntersectionType::TsUnionType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::TsUnionOrIntersectionType(
-                        self,
-                        self::fields::TsUnionOrIntersectionTypeField::TsUnionType,
-                    ));
-                <TsUnionType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsUnionType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentNodeRef::TsUnionOrIntersectionType(
-                        self,
-                        self::fields::TsUnionOrIntersectionTypeField::TsIntersectionType,
-                    ));
-                <TsIntersectionType as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIntersectionType as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsUnionType {
-    #[doc = "Calls [VisitAstPath`::visit_ts_union_type`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_union_type(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for TsUnionType {
+    #[doc = "Calls [Visit`::visit_ts_union_type`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_union_type(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             TsUnionType { span, types } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsUnionType(
-                        self,
-                        self::fields::TsUnionTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsUnionType(
-                        self,
-                        self::fields::TsUnionTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitWith<V>>::visit_with(types, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnaryExpr {
-    #[doc = "Calls [VisitAstPath`::visit_unary_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unary_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UnaryExpr {
+    #[doc = "Calls [Visit`::visit_unary_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_unary_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UnaryExpr { span, op, arg } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnaryExpr(
-                        self,
-                        self::fields::UnaryExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnaryExpr(
-                        self,
-                        self::fields::UnaryExprField::Op,
-                    ));
-                    <UnaryOp as VisitWithAstPath<V>>::visit_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <UnaryOp as VisitWith<V>>::visit_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnaryExpr(
-                        self,
-                        self::fields::UnaryExprField::Arg,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnaryOp {
-    #[doc = "Calls [VisitAstPath`::visit_unary_op`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_unary_op(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UnaryOp {
+    #[doc = "Calls [Visit`::visit_unary_op`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_unary_op(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UnaryOp::Minus => {}
             UnaryOp::Plus => {}
@@ -48083,23 +15239,13 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnaryOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UpdateExpr {
-    #[doc = "Calls [VisitAstPath`::visit_update_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_update_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UpdateExpr {
+    #[doc = "Calls [Visit`::visit_update_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_update_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UpdateExpr {
                 span,
@@ -48108,82 +15254,38 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UpdateExpr {
                 arg,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UpdateExpr(
-                        self,
-                        self::fields::UpdateExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UpdateExpr(
-                        self,
-                        self::fields::UpdateExprField::Op,
-                    ));
-                    <UpdateOp as VisitWithAstPath<V>>::visit_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <UpdateOp as VisitWith<V>>::visit_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UpdateExpr(
-                        self,
-                        self::fields::UpdateExprField::Arg,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UpdateOp {
-    #[doc = "Calls [VisitAstPath`::visit_update_op`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_update_op(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UpdateOp {
+    #[doc = "Calls [Visit`::visit_update_op`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_update_op(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UpdateOp::PlusPlus => {}
             UpdateOp::MinusMinus => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UsingDecl {
-    #[doc = "Calls [VisitAstPath`::visit_using_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_using_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for UsingDecl {
+    #[doc = "Calls [Visit`::visit_using_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_using_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             UsingDecl {
                 span,
@@ -48191,48 +15293,22 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UsingDecl {
                 decls,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UsingDecl(
-                        self,
-                        self::fields::UsingDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UsingDecl(
-                        self,
-                        self::fields::UsingDeclField::Decls(usize::MAX),
-                    ));
-                    <Vec<VarDeclarator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decls,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<VarDeclarator> as VisitWith<V>>::visit_with(decls, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDecl {
-    #[doc = "Calls [VisitAstPath`::visit_var_decl`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for VarDecl {
+    #[doc = "Calls [Visit`::visit_var_decl`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_var_decl(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             VarDecl {
                 span,
@@ -48242,70 +15318,28 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDecl {
                 decls,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
-                        self,
-                        self::fields::VarDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
-                        self,
-                        self::fields::VarDeclField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitWith<V>>::visit_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
-                        self,
-                        self::fields::VarDeclField::Kind,
-                    ));
-                    <VarDeclKind as VisitWithAstPath<V>>::visit_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <VarDeclKind as VisitWith<V>>::visit_with(kind, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
-                        self,
-                        self::fields::VarDeclField::Decls(usize::MAX),
-                    ));
-                    <Vec<VarDeclarator> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        decls,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<VarDeclarator> as VisitWith<V>>::visit_with(decls, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclKind {
-    #[doc = "Calls [VisitAstPath`::visit_var_decl_kind`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for VarDeclKind {
+    #[doc = "Calls [Visit`::visit_var_decl_kind`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_var_decl_kind(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             VarDeclKind::Var => {}
             VarDeclKind::Let => {}
@@ -48313,66 +15347,30 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclOrExpr {
-    #[doc = "Calls [VisitAstPath`::visit_var_decl_or_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_decl_or_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for VarDeclOrExpr {
+    #[doc = "Calls [Visit`::visit_var_decl_or_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_var_decl_or_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             VarDeclOrExpr::VarDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclOrExpr(
-                    self,
-                    self::fields::VarDeclOrExprField::VarDecl,
-                ));
-                <Box<VarDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<VarDecl> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
             VarDeclOrExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclOrExpr(
-                    self,
-                    self::fields::VarDeclOrExprField::Expr,
-                ));
-                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitWith<V>>::visit_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclarator {
-    #[doc = "Calls [VisitAstPath`::visit_var_declarator`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_declarator(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for VarDeclarator {
+    #[doc = "Calls [Visit`::visit_var_declarator`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_var_declarator(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             VarDeclarator {
                 span,
@@ -48381,171 +15379,69 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclarator {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclarator(
-                        self,
-                        self::fields::VarDeclaratorField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclarator(
-                        self,
-                        self::fields::VarDeclaratorField::Name,
-                    ));
-                    <Pat as VisitWithAstPath<V>>::visit_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Pat as VisitWith<V>>::visit_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclarator(
-                        self,
-                        self::fields::VarDeclaratorField::Init,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(init, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WhileStmt {
-    #[doc = "Calls [VisitAstPath`::visit_while_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_while_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for WhileStmt {
+    #[doc = "Calls [Visit`::visit_while_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_while_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             WhileStmt { span, test, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WhileStmt(
-                        self,
-                        self::fields::WhileStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WhileStmt(
-                        self,
-                        self::fields::WhileStmtField::Test,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WhileStmt(
-                        self,
-                        self::fields::WhileStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WithStmt {
-    #[doc = "Calls [VisitAstPath`::visit_with_stmt`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_with_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for WithStmt {
+    #[doc = "Calls [Visit`::visit_with_stmt`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_with_stmt(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             WithStmt { span, obj, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WithStmt(
-                        self,
-                        self::fields::WithStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WithStmt(
-                        self,
-                        self::fields::WithStmtField::Obj,
-                    ));
-                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitWith<V>>::visit_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WithStmt(
-                        self,
-                        self::fields::WithStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitWith<V>>::visit_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for YieldExpr {
-    #[doc = "Calls [VisitAstPath`::visit_yield_expr`] with `self`."]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_yield_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for YieldExpr {
+    #[doc = "Calls [Visit`::visit_yield_expr`] with `self`."]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_yield_expr(visitor, self)
     }
 
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             YieldExpr {
                 span,
@@ -48553,11650 +15449,17396 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for YieldExpr {
                 delegate,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::YieldExpr(
-                        self,
-                        self::fields::YieldExprField::Span,
-                    ));
-                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitWith<V>>::visit_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::YieldExpr(
-                        self,
-                        self::fields::YieldExprField::Arg,
-                    ));
-                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitWith<V>>::visit_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitAstPath`::visit_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for swc_atoms::Atom {
+    #[doc = "Calls [Visit`::visit_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BigIntValue {
-    #[doc = "Calls [VisitAstPath`::visit_big_int_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for BigIntValue {
+    #[doc = "Calls [Visit`::visit_big_int_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_big_int_value(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_big_int_value(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ClassMember] {
-    #[doc = "Calls [VisitAstPath`::visit_class_members`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ClassMember] {
+    #[doc = "Calls [Visit`::visit_class_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_class_members(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_class_members(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ClassMember as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ClassMember as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Decorator] {
-    #[doc = "Calls [VisitAstPath`::visit_decorators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Decorator] {
+    #[doc = "Calls [Visit`::visit_decorators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_decorators(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_decorators(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Decorator as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Decorator as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExportSpecifier] {
-    #[doc = "Calls [VisitAstPath`::visit_export_specifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ExportSpecifier] {
+    #[doc = "Calls [Visit`::visit_export_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_export_specifiers(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_export_specifiers(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ExportSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ExportSpecifier as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExprOrSpread] {
-    #[doc = "Calls [VisitAstPath`::visit_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ExprOrSpread] {
+    #[doc = "Calls [Visit`::visit_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_expr_or_spreads(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ExprOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ExprOrSpread as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<Expr>] {
-    #[doc = "Calls [VisitAstPath`::visit_exprs`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Box<Expr>] {
+    #[doc = "Calls [Visit`::visit_exprs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_exprs(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_exprs(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Box<Expr> as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportSpecifier] {
-    #[doc = "Calls [VisitAstPath`::visit_import_specifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ImportSpecifier] {
+    #[doc = "Calls [Visit`::visit_import_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_specifiers(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_specifiers(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ImportSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ImportSpecifier as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportWithItem] {
-    #[doc = "Calls [VisitAstPath`::visit_import_with_items`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ImportWithItem] {
+    #[doc = "Calls [Visit`::visit_import_with_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_import_with_items(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_import_with_items(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ImportWithItem as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ImportWithItem as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXAttrOrSpread] {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [JSXAttrOrSpread] {
+    #[doc = "Calls [Visit`::visit_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_attr_or_spreads(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_attr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <JSXAttrOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <JSXAttrOrSpread as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXElementChild] {
-    #[doc = "Calls [VisitAstPath`::visit_jsx_element_childs`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [JSXElementChild] {
+    #[doc = "Calls [Visit`::visit_jsx_element_childs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_jsx_element_childs(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_jsx_element_childs(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <JSXElementChild as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <JSXElementChild as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ModuleItem] {
-    #[doc = "Calls [VisitAstPath`::visit_module_items`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ModuleItem] {
+    #[doc = "Calls [Visit`::visit_module_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_module_items(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_module_items(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ModuleItem as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ModuleItem as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ObjectPatProp] {
-    #[doc = "Calls [VisitAstPath`::visit_object_pat_props`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ObjectPatProp] {
+    #[doc = "Calls [Visit`::visit_object_pat_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_object_pat_props(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_object_pat_props(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ObjectPatProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ObjectPatProp as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Accessibility> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_accessibility`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Accessibility> {
+    #[doc = "Calls [Visit`::visit_opt_accessibility`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_accessibility(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_accessibility(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Accessibility as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Accessibility as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [Visit`::visit_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <swc_atoms::Atom as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<BlockStmt> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_block_stmt`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<BlockStmt> {
+    #[doc = "Calls [Visit`::visit_opt_block_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_block_stmt(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_block_stmt(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <BlockStmt as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<CatchClause> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_catch_clause`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<CatchClause> {
+    #[doc = "Calls [Visit`::visit_opt_catch_clause`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_catch_clause(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_catch_clause(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <CatchClause as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <CatchClause as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Expr>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_expr`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Expr>> {
+    #[doc = "Calls [Visit`::visit_opt_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_expr(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Box<Expr> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ExprOrSpread> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_expr_or_spread`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<ExprOrSpread> {
+    #[doc = "Calls [Visit`::visit_opt_expr_or_spread`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr_or_spread(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_expr_or_spread(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <ExprOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ExprOrSpread as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<ExprOrSpread>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<ExprOrSpread>> {
+    #[doc = "Calls [Visit`::visit_opt_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_expr_or_spreads(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Vec<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Vec<ExprOrSpread> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ident`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Ident> {
+    #[doc = "Calls [Visit`::visit_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ident(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ident(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Ident as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXAttrValue> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_jsx_attr_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<JSXAttrValue> {
+    #[doc = "Calls [Visit`::visit_opt_jsx_attr_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_jsx_attr_value(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_jsx_attr_value(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <JSXAttrValue as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <JSXAttrValue as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXClosingElement> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_jsx_closing_element`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<JSXClosingElement> {
+    #[doc = "Calls [Visit`::visit_opt_jsx_closing_element`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_jsx_closing_element(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_jsx_closing_element(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <JSXClosingElement as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <JSXClosingElement as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ModuleExportName> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_module_export_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<ModuleExportName> {
+    #[doc = "Calls [Visit`::visit_opt_module_export_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_module_export_name(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_module_export_name(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <ModuleExportName as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ModuleExportName as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ObjectLit>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_object_lit`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ObjectLit>> {
+    #[doc = "Calls [Visit`::visit_opt_object_lit`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_object_lit(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_object_lit(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<ObjectLit> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<ObjectLit> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Pat> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_pat`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Pat> {
+    #[doc = "Calls [Visit`::visit_opt_pat`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_pat(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_pat(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Pat as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Pat as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_common::Span> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_span`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_common::Span> {
+    #[doc = "Calls [Visit`::visit_opt_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_span(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_span(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <swc_common::Span as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Stmt>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_stmt`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Stmt>> {
+    #[doc = "Calls [Visit`::visit_opt_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_stmt(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_stmt(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Box<Stmt> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Str>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_str`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Str>> {
+    #[doc = "Calls [Visit`::visit_opt_str`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_str(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_str(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Box<Str> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TruePlusMinus> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_true_plus_minus`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<TruePlusMinus> {
+    #[doc = "Calls [Visit`::visit_opt_true_plus_minus`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_true_plus_minus(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_true_plus_minus(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <TruePlusMinus as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <TruePlusMinus as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsEntityName> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ts_entity_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<TsEntityName> {
+    #[doc = "Calls [Visit`::visit_opt_ts_entity_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_entity_name(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ts_entity_name(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <TsEntityName as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsNamespaceBody> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ts_namespace_body`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<TsNamespaceBody> {
+    #[doc = "Calls [Visit`::visit_opt_ts_namespace_body`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_namespace_body(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ts_namespace_body(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <TsNamespaceBody as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <TsNamespaceBody as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsType>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsType>> {
+    #[doc = "Calls [Visit`::visit_opt_ts_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ts_type(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<TsType> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeAnn>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type_ann`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeAnn>> {
+    #[doc = "Calls [Visit`::visit_opt_ts_type_ann`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_ann(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ts_type_ann(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<TsTypeAnn> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<TsTypeAnn> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamDecl>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeParamDecl>> {
+    #[doc = "Calls [Visit`::visit_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_param_decl(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ts_type_param_decl(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<TsTypeParamDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<TsTypeParamDecl> as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamInstantiation>> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type_param_instantiation`] with `self`. (Extra \
-             impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeParamInstantiation>> {
+    #[doc = "Calls [Visit`::visit_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_ts_type_param_instantiation(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Box<TsTypeParamInstantiation> as VisitWithAstPath<V>>::visit_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <Box<TsTypeParamInstantiation> as VisitWith<V>>::visit_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<VarDeclOrExpr> {
-    #[doc = "Calls [VisitAstPath`::visit_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for Option<VarDeclOrExpr> {
+    #[doc = "Calls [Visit`::visit_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_var_decl_or_expr(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_var_decl_or_expr(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         match self {
-            Some(inner) => <VarDeclOrExpr as VisitWithAstPath<V>>::visit_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <VarDeclOrExpr as VisitWith<V>>::visit_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<ExprOrSpread>] {
-    #[doc = "Calls [VisitAstPath`::visit_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Option<ExprOrSpread>] {
+    #[doc = "Calls [Visit`::visit_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_vec_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Option<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Option<ExprOrSpread> as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<Pat>] {
-    #[doc = "Calls [VisitAstPath`::visit_opt_vec_pats`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Option<Pat>] {
+    #[doc = "Calls [Visit`::visit_opt_vec_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_opt_vec_pats(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_opt_vec_pats(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Option<Pat> as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ParamOrTsParamProp] {
-    #[doc = "Calls [VisitAstPath`::visit_param_or_ts_param_props`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [ParamOrTsParamProp] {
+    #[doc = "Calls [Visit`::visit_param_or_ts_param_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_param_or_ts_param_props(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_param_or_ts_param_props(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ParamOrTsParamProp as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <ParamOrTsParamProp as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Param] {
-    #[doc = "Calls [VisitAstPath`::visit_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Param] {
+    #[doc = "Calls [Visit`::visit_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_params(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_params(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Param as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Param as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Pat] {
-    #[doc = "Calls [VisitAstPath`::visit_pats`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Pat] {
+    #[doc = "Calls [Visit`::visit_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_pats(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_pats(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Pat as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Pat as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PropOrSpread] {
-    #[doc = "Calls [VisitAstPath`::visit_prop_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [PropOrSpread] {
+    #[doc = "Calls [Visit`::visit_prop_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_prop_or_spreads(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_prop_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PropOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <PropOrSpread as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
-    #[doc = "Calls [VisitAstPath`::visit_span`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
+impl<V: ?Sized + Visit> VisitWith<V> for swc_common::Span {
+    #[doc = "Calls [Visit`::visit_span`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_span(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Stmt] {
-    #[doc = "Calls [VisitAstPath`::visit_stmts`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Stmt] {
+    #[doc = "Calls [Visit`::visit_stmts`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_stmts(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_stmts(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Stmt as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Stmt as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SwitchCase] {
-    #[doc = "Calls [VisitAstPath`::visit_switch_cases`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [SwitchCase] {
+    #[doc = "Calls [Visit`::visit_switch_cases`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_switch_cases(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_switch_cases(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <SwitchCase as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <SwitchCase as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::SyntaxContext {
-    #[doc = "Calls [VisitAstPath`::visit_syntax_context`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for swc_common::SyntaxContext {
+    #[doc = "Calls [Visit`::visit_syntax_context`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_syntax_context(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_syntax_context(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
+    fn visit_children_with(&self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TplElement] {
-    #[doc = "Calls [VisitAstPath`::visit_tpl_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [TplElement] {
+    #[doc = "Calls [Visit`::visit_tpl_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_tpl_elements(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_tpl_elements(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TplElement as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <TplElement as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsEnumMember] {
-    #[doc = "Calls [VisitAstPath`::visit_ts_enum_members`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [TsEnumMember] {
+    #[doc = "Calls [Visit`::visit_ts_enum_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_enum_members(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_enum_members(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsEnumMember as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <TsEnumMember as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsExprWithTypeArgs] {
-    #[doc = "Calls [VisitAstPath`::visit_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [TsExprWithTypeArgs] {
+    #[doc = "Calls [Visit`::visit_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_expr_with_type_argss(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_expr_with_type_argss(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsExprWithTypeArgs as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <TsExprWithTypeArgs as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsFnParam] {
-    #[doc = "Calls [VisitAstPath`::visit_ts_fn_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [TsFnParam] {
+    #[doc = "Calls [Visit`::visit_ts_fn_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_fn_params(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_fn_params(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsFnParam as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <TsFnParam as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTupleElement] {
-    #[doc = "Calls [VisitAstPath`::visit_ts_tuple_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [TsTupleElement] {
+    #[doc = "Calls [Visit`::visit_ts_tuple_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_tuple_elements(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_tuple_elements(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsTupleElement as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <TsTupleElement as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeElement] {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [TsTypeElement] {
+    #[doc = "Calls [Visit`::visit_ts_type_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_elements(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_elements(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsTypeElement as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <TsTypeElement as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeParam] {
-    #[doc = "Calls [VisitAstPath`::visit_ts_type_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [TsTypeParam] {
+    #[doc = "Calls [Visit`::visit_ts_type_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_type_params(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_type_params(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsTypeParam as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <TsTypeParam as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<TsType>] {
-    #[doc = "Calls [VisitAstPath`::visit_ts_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [Box<TsType>] {
+    #[doc = "Calls [Visit`::visit_ts_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_ts_types(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_ts_types(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <Box<TsType> as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [VarDeclarator] {
-    #[doc = "Calls [VisitAstPath`::visit_var_declarators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Visit> VisitWith<V> for [VarDeclarator] {
+    #[doc = "Calls [Visit`::visit_var_declarators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        <V as VisitAstPath>::visit_var_declarators(visitor, self, __ast_path)
+    fn visit_with(&self, visitor: &mut V) {
+        <V as Visit>::visit_var_declarators(visitor, self)
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        self.iter().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <VarDeclarator as VisitWithAstPath<V>>::visit_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_children_with(&self, visitor: &mut V) {
+        self.iter()
+            .for_each(|item| <VarDeclarator as VisitWith<V>>::visit_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> VisitWithAstPath<V> for std::boxed::Box<T>
+impl<V, T> VisitWith<V> for std::boxed::Box<T>
 where
-    V: ?Sized + VisitAstPath,
-    T: VisitWithAstPath<V>,
+    V: ?Sized + Visit,
+    T: VisitWith<V>,
 {
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        let v = <T as VisitWithAstPath<V>>::visit_with_ast_path(&**self, visitor, __ast_path);
+    fn visit_with(&self, visitor: &mut V) {
+        let v = <T as VisitWith<V>>::visit_with(&**self, visitor);
         v
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        let v =
-            <T as VisitWithAstPath<V>>::visit_children_with_ast_path(&**self, visitor, __ast_path);
+    fn visit_children_with(&self, visitor: &mut V) {
+        let v = <T as VisitWith<V>>::visit_children_with(&**self, visitor);
         v
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> VisitWithAstPath<V> for std::vec::Vec<T>
+impl<V, T> VisitWith<V> for std::vec::Vec<T>
 where
-    V: ?Sized + VisitAstPath,
-    [T]: VisitWithAstPath<V>,
+    V: ?Sized + Visit,
+    [T]: VisitWith<V>,
 {
     #[inline]
-    fn visit_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        let v = <[T] as VisitWithAstPath<V>>::visit_with_ast_path(self, visitor, __ast_path);
+    fn visit_with(&self, visitor: &mut V) {
+        let v = <[T] as VisitWith<V>>::visit_with(self, visitor);
         v
     }
 
     #[inline]
-    fn visit_children_with_ast_path<'ast: 'r, 'r>(
-        &'ast self,
-        visitor: &mut V,
-        __ast_path: &mut AstNodePath<'r>,
-    ) {
-        let v =
-            <[T] as VisitWithAstPath<V>>::visit_children_with_ast_path(self, visitor, __ast_path);
+    fn visit_children_with(&self, visitor: &mut V) {
+        let v = <[T] as VisitWith<V>>::visit_children_with(self, visitor);
         v
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-pub trait VisitMut {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait VisitAstPath {
     #[doc = "Visit a node of type `Accessibility`.\n\nBy default, this method calls \
-             [`Accessibility::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Accessibility::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
-        <Accessibility as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Accessibility,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Accessibility as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ArrayLit`.\n\nBy default, this method calls \
-             [`ArrayLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ArrayLit::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
-        <ArrayLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_array_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ArrayLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ArrayPat`.\n\nBy default, this method calls \
-             [`ArrayPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ArrayPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
-        <ArrayPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_array_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ArrayPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ArrowExpr`.\n\nBy default, this method calls \
-             [`ArrowExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ArrowExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
-        <ArrowExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_arrow_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrowExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ArrowExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignExpr`.\n\nBy default, this method calls \
-             [`AssignExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
-        <AssignExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_assign_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AssignExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignOp`.\n\nBy default, this method calls \
-             [`AssignOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
-        <AssignOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_assign_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AssignOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignPat`.\n\nBy default, this method calls \
-             [`AssignPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
-        <AssignPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_assign_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AssignPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignPatProp`.\n\nBy default, this method calls \
-             [`AssignPatProp::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AssignPatProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
-        <AssignPatProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_assign_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AssignPatProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignProp`.\n\nBy default, this method calls \
-             [`AssignProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
-        <AssignProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_assign_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AssignProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignTarget`.\n\nBy default, this method calls \
-             [`AssignTarget::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AssignTarget::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
-        <AssignTarget as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AssignTarget as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignTargetPat`.\n\nBy default, this method calls \
-             [`AssignTargetPat::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignTargetPat::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
-        <AssignTargetPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_assign_target_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTargetPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AssignTargetPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`swc_atoms :: Atom::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
-        <swc_atoms::Atom as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <swc_atoms::Atom as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AutoAccessor`.\n\nBy default, this method calls \
-             [`AutoAccessor::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AutoAccessor::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
-        <AutoAccessor as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_auto_accessor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AutoAccessor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AutoAccessor as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AwaitExpr`.\n\nBy default, this method calls \
-             [`AwaitExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AwaitExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
-        <AwaitExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_await_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AwaitExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <AwaitExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BigInt`.\n\nBy default, this method calls \
-             [`BigInt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`BigInt::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
-        <BigInt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_big_int<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigInt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BigInt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BigIntValue`.\n\nBy default, this method calls \
-             [`BigIntValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BigIntValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
-        <BigIntValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_big_int_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigIntValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BigIntValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BinExpr`.\n\nBy default, this method calls \
-             [`BinExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BinExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
-        <BinExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_bin_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BinExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BinaryOp`.\n\nBy default, this method calls \
-             [`BinaryOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BinaryOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
-        <BinaryOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_binary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BinaryOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BindingIdent`.\n\nBy default, this method calls \
-             [`BindingIdent::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`BindingIdent::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
-        <BindingIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_binding_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BindingIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BindingIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BlockStmt`.\n\nBy default, this method calls \
-             [`BlockStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BlockStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
-        <BlockStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BlockStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BlockStmtOrExpr`.\n\nBy default, this method calls \
-             [`BlockStmtOrExpr::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BlockStmtOrExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
-        <BlockStmtOrExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmtOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BlockStmtOrExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Bool`.\n\nBy default, this method calls \
-             [`Bool::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Bool::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool) {
-        <Bool as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
+        <Bool as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BreakStmt`.\n\nBy default, this method calls \
-             [`BreakStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BreakStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
-        <BreakStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_break_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BreakStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <BreakStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CallExpr`.\n\nBy default, this method calls \
-             [`CallExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CallExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
-        <CallExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_call_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CallExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <CallExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Callee`.\n\nBy default, this method calls \
-             [`Callee::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Callee::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee) {
-        <Callee as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
+        <Callee as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CatchClause`.\n\nBy default, this method calls \
-             [`CatchClause::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CatchClause::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
-        <CatchClause as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CatchClause,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <CatchClause as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Class`.\n\nBy default, this method calls \
-             [`Class::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Class::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class) {
-        <Class as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
+        <Class as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ClassDecl`.\n\nBy default, this method calls \
-             [`ClassDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
-        <ClassDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_class_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ClassDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ClassExpr`.\n\nBy default, this method calls \
-             [`ClassExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
-        <ClassExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_class_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ClassExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ClassMember`.\n\nBy default, this method calls \
-             [`ClassMember::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassMember::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
-        <ClassMember as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_class_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ClassMember as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ClassMember >`.\n\nBy default, this method calls [`Vec < \
-             ClassMember >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             ClassMember >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
-        <Vec<ClassMember> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_class_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ClassMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ClassMember] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassMethod`.\n\nBy default, this method calls \
-             [`ClassMethod::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassMethod::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
-        <ClassMethod as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_class_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ClassMethod as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassProp`.\n\nBy default, this method calls \
-             [`ClassProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassProp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
-        <ClassProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_class_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ClassProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ComputedPropName`.\n\nBy default, this method calls \
-             [`ComputedPropName::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ComputedPropName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
-        <ComputedPropName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_computed_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComputedPropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ComputedPropName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CondExpr`.\n\nBy default, this method calls \
-             [`CondExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CondExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
-        <CondExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_cond_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CondExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <CondExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Constructor`.\n\nBy default, this method calls \
-             [`Constructor::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Constructor::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
-        <Constructor as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_constructor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Constructor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Constructor as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContinueStmt`.\n\nBy default, this method calls \
-             [`ContinueStmt::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ContinueStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
-        <ContinueStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_continue_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContinueStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ContinueStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DebuggerStmt`.\n\nBy default, this method calls \
-             [`DebuggerStmt::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`DebuggerStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
-        <DebuggerStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_debugger_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DebuggerStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DebuggerStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Decl`.\n\nBy default, this method calls \
-             [`Decl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Decl::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl) {
-        <Decl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
+        <Decl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Decorator`.\n\nBy default, this method calls \
-             [`Decorator::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Decorator::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
-        <Decorator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_decorator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Decorator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Decorator as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Decorator >`.\n\nBy default, this method calls [`Vec < \
-             Decorator >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             Decorator >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
-        <Vec<Decorator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_decorators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Decorator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[Decorator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DefaultDecl`.\n\nBy default, this method calls \
-             [`DefaultDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DefaultDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
-        <DefaultDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DefaultDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DoWhileStmt`.\n\nBy default, this method calls \
-             [`DoWhileStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DoWhileStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
-        <DoWhileStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_do_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DoWhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <DoWhileStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `EmptyStmt`.\n\nBy default, this method calls \
-             [`EmptyStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`EmptyStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
-        <EmptyStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_empty_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EmptyStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <EmptyStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `EsVersion`.\n\nBy default, this method calls \
-             [`EsVersion::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`EsVersion::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
-        <EsVersion as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_es_version<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EsVersion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <EsVersion as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExportAll`.\n\nBy default, this method calls \
-             [`ExportAll::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExportAll::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
-        <ExportAll as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_all<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportAll,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportAll as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExportDecl`.\n\nBy default, this method calls \
-             [`ExportDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExportDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
-        <ExportDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExportDefaultDecl`.\n\nBy default, this method calls \
-             [`ExportDefaultDecl::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportDefaultDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
-        <ExportDefaultDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportDefaultDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDefaultExpr`.\n\nBy default, this method calls \
-             [`ExportDefaultExpr::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportDefaultExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
-        <ExportDefaultExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_default_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportDefaultExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ExportDefaultSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ExportDefaultSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
-        <ExportDefaultSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportDefaultSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamedSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ExportNamedSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
-        <ExportNamedSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportNamedSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportNamespaceSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamespaceSpecifier::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ExportNamespaceSpecifier::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
-        <ExportNamespaceSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamespaceSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportNamespaceSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportSpecifier`.\n\nBy default, this method calls \
-             [`ExportSpecifier::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportSpecifier::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
-        <ExportSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExportSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ExportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ExportSpecifier >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < ExportSpecifier >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
-        <Vec<ExportSpecifier> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_export_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ExportSpecifier] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Expr`.\n\nBy default, this method calls \
-             [`Expr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Expr::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr) {
-        <Expr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
+        <Expr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExprOrSpread`.\n\nBy default, this method calls \
-             [`ExprOrSpread::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ExprOrSpread::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
-        <ExprOrSpread as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExprOrSpread as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ExprOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             ExprOrSpread >::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             ExprOrSpread >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
-        <Vec<ExprOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExprOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ExprOrSpread] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExprStmt`.\n\nBy default, this method calls \
-             [`ExprStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExprStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
-        <ExprStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_expr_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ExprStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Box < Expr > >`.\n\nBy default, this method calls [`Vec < \
-             Box < Expr > >::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             Box < Expr > >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
-        <Vec<Box<Expr>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_exprs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<Expr>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[Box<Expr>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FnDecl`.\n\nBy default, this method calls \
-             [`FnDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`FnDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
-        <FnDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_fn_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <FnDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `FnExpr`.\n\nBy default, this method calls \
-             [`FnExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`FnExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
-        <FnExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_fn_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <FnExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForHead`.\n\nBy default, this method calls \
-             [`ForHead::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForHead::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
-        <ForHead as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_for_head<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForHead,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForHead as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForInStmt`.\n\nBy default, this method calls \
-             [`ForInStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForInStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
-        <ForInStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_for_in_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForInStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForInStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForOfStmt`.\n\nBy default, this method calls \
-             [`ForOfStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForOfStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
-        <ForOfStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_for_of_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForOfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForOfStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForStmt`.\n\nBy default, this method calls \
-             [`ForStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
-        <ForStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_for_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ForStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Function::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
-        <Function as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Function as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `GetterProp`.\n\nBy default, this method calls \
-             [`GetterProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`GetterProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
-        <GetterProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_getter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast GetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <GetterProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Ident::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
-        <Ident as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
+        <Ident as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `IdentName`.\n\nBy default, this method calls \
-             [`IdentName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`IdentName::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
-        <IdentName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ident_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdentName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <IdentName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `IfStmt`.\n\nBy default, this method calls \
-             [`IfStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`IfStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
-        <IfStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_if_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <IfStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Import`.\n\nBy default, this method calls \
-             [`Import::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Import::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import) {
-        <Import as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
+        <Import as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportDecl`.\n\nBy default, this method calls \
-             [`ImportDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
-        <ImportDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ImportDefaultSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ImportDefaultSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
-        <ImportDefaultSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportDefaultSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ImportNamedSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ImportNamedSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
-        <ImportNamedSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportNamedSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportPhase`.\n\nBy default, this method calls \
-             [`ImportPhase::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportPhase::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
-        <ImportPhase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_phase<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPhase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportPhase as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportSpecifier`.\n\nBy default, this method calls \
-             [`ImportSpecifier::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportSpecifier::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
-        <ImportSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ImportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ImportSpecifier >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < ImportSpecifier >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
-        <Vec<ImportSpecifier> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ImportSpecifier] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportStarAsSpecifier`.\n\nBy default, this method calls \
-             [`ImportStarAsSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ImportStarAsSpecifier::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
-        <ImportStarAsSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportStarAsSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportStarAsSpecifier as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportWith`.\n\nBy default, this method calls \
-             [`ImportWith::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportWith::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
-        <ImportWith as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_with<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWith,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportWith as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
-             [`ImportWithItem::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ImportWithItem::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
-        <ImportWithItem as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_with_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWithItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ImportWithItem as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ImportWithItem >`.\n\nBy default, this method calls [`Vec \
-             < ImportWithItem >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             < ImportWithItem >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
-        <Vec<ImportWithItem> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_import_with_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportWithItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ImportWithItem] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Invalid`.\n\nBy default, this method calls \
-             [`Invalid::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Invalid::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
-        <Invalid as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_invalid<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Invalid,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Invalid as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXAttr`.\n\nBy default, this method calls \
-             [`JSXAttr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXAttr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
-        <JSXAttr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_attr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXAttr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXAttrName`.\n\nBy default, this method calls \
-             [`JSXAttrName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXAttrName::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
-        <JSXAttrName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_attr_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXAttrName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXAttrOrSpread`.\n\nBy default, this method calls \
-             [`JSXAttrOrSpread::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXAttrOrSpread::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
-        <JSXAttrOrSpread as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXAttrOrSpread as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < JSXAttrOrSpread >`.\n\nBy default, this method calls \
-             [`Vec < JSXAttrOrSpread >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < JSXAttrOrSpread >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
-        <Vec<JSXAttrOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXAttrOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[JSXAttrOrSpread] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXAttrValue`.\n\nBy default, this method calls \
-             [`JSXAttrValue::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXAttrValue::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
-        <JSXAttrValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXAttrValue as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXClosingElement`.\n\nBy default, this method calls \
-             [`JSXClosingElement::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXClosingElement::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
-        <JSXClosingElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXClosingElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXClosingFragment`.\n\nBy default, this method calls \
-             [`JSXClosingFragment::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXClosingFragment::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
-        <JSXClosingFragment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXClosingFragment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXElement`.\n\nBy default, this method calls \
-             [`JSXElement::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
-        <JSXElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXElementChild`.\n\nBy default, this method calls \
-             [`JSXElementChild::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXElementChild::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
-        <JSXElementChild as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_element_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXElementChild as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < JSXElementChild >`.\n\nBy default, this method calls \
-             [`Vec < JSXElementChild >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < JSXElementChild >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
-        <Vec<JSXElementChild> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_element_childs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXElementChild],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[JSXElementChild] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXElementName`.\n\nBy default, this method calls \
-             [`JSXElementName::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXElementName::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
-        <JSXElementName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_element_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXElementName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXEmptyExpr`.\n\nBy default, this method calls \
-             [`JSXEmptyExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXEmptyExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
-        <JSXEmptyExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXEmptyExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXEmptyExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXExpr`.\n\nBy default, this method calls \
-             [`JSXExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
-        <JSXExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
-             [`JSXExprContainer::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXExprContainer::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
-        <JSXExprContainer as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_expr_container<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExprContainer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXExprContainer as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXFragment`.\n\nBy default, this method calls \
-             [`JSXFragment::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXFragment::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
-        <JSXFragment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXFragment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXMemberExpr`.\n\nBy default, this method calls \
-             [`JSXMemberExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXMemberExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
-        <JSXMemberExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXMemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXMemberExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXNamespacedName`.\n\nBy default, this method calls \
-             [`JSXNamespacedName::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXNamespacedName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
-        <JSXNamespacedName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXNamespacedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXNamespacedName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXObject`.\n\nBy default, this method calls \
-             [`JSXObject::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXObject::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
-        <JSXObject as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_object<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXObject,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXObject as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXOpeningElement`.\n\nBy default, this method calls \
-             [`JSXOpeningElement::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXOpeningElement::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
-        <JSXOpeningElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_opening_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXOpeningElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXOpeningFragment`.\n\nBy default, this method calls \
-             [`JSXOpeningFragment::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXOpeningFragment::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
-        <JSXOpeningFragment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXOpeningFragment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXSpreadChild`.\n\nBy default, this method calls \
-             [`JSXSpreadChild::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXSpreadChild::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
-        <JSXSpreadChild as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_spread_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXSpreadChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXSpreadChild as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXText`.\n\nBy default, this method calls \
-             [`JSXText::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXText::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
-        <JSXText as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_jsx_text<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXText,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <JSXText as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Key`.\n\nBy default, this method calls \
-             [`Key::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Key::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key) {
-        <Key as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
+        <Key as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `KeyValuePatProp`.\n\nBy default, this method calls \
-             [`KeyValuePatProp::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`KeyValuePatProp::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
-        <KeyValuePatProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValuePatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <KeyValuePatProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyValueProp`.\n\nBy default, this method calls \
-             [`KeyValueProp::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`KeyValueProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
-        <KeyValueProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_key_value_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValueProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <KeyValueProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LabeledStmt`.\n\nBy default, this method calls \
-             [`LabeledStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`LabeledStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
-        <LabeledStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_labeled_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LabeledStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <LabeledStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Lit`.\n\nBy default, this method calls \
-             [`Lit::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Lit::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit) {
-        <Lit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
+        <Lit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MemberExpr`.\n\nBy default, this method calls \
-             [`MemberExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MemberExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
-        <MemberExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MemberExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MemberProp`.\n\nBy default, this method calls \
-             [`MemberProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MemberProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
-        <MemberProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_member_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MemberProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MetaPropExpr`.\n\nBy default, this method calls \
-             [`MetaPropExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MetaPropExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
-        <MetaPropExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_meta_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MetaPropExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MetaPropKind`.\n\nBy default, this method calls \
-             [`MetaPropKind::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MetaPropKind::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
-        <MetaPropKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_meta_prop_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MetaPropKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MethodKind`.\n\nBy default, this method calls \
-             [`MethodKind::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MethodKind::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
-        <MethodKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_method_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MethodKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MethodProp`.\n\nBy default, this method calls \
-             [`MethodProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MethodProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
-        <MethodProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_method_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <MethodProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Module`.\n\nBy default, this method calls \
-             [`Module::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Module::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module) {
-        <Module as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
+        <Module as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ModuleDecl`.\n\nBy default, this method calls \
-             [`ModuleDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ModuleDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
-        <ModuleDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ModuleDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ModuleExportName`.\n\nBy default, this method calls \
-             [`ModuleExportName::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ModuleExportName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
-        <ModuleExportName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleExportName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ModuleExportName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ModuleItem`.\n\nBy default, this method calls \
-             [`ModuleItem::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ModuleItem::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
-        <ModuleItem as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_module_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ModuleItem as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < ModuleItem >`.\n\nBy default, this method calls [`Vec < \
-             ModuleItem >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             ModuleItem >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
-        <Vec<ModuleItem> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_module_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ModuleItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ModuleItem] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamedExport`.\n\nBy default, this method calls \
-             [`NamedExport::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NamedExport::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
-        <NamedExport as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_named_export<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedExport,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NamedExport as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NewExpr`.\n\nBy default, this method calls \
-             [`NewExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NewExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
-        <NewExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_new_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NewExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <NewExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Null`.\n\nBy default, this method calls \
-             [`Null::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Null::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null) {
-        <Null as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
+        <Null as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Number::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
-        <Number as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
+        <Number as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ObjectLit`.\n\nBy default, this method calls \
-             [`ObjectLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ObjectLit::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
-        <ObjectLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ObjectLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ObjectPat`.\n\nBy default, this method calls \
-             [`ObjectPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ObjectPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
-        <ObjectPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_object_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ObjectPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ObjectPatProp`.\n\nBy default, this method calls \
-             [`ObjectPatProp::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ObjectPatProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
-        <ObjectPatProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_object_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ObjectPatProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ObjectPatProp >`.\n\nBy default, this method calls [`Vec \
-             < ObjectPatProp >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             < ObjectPatProp >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
-        <Vec<ObjectPatProp> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_object_pat_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ObjectPatProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ObjectPatProp] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Accessibility >`.\n\nBy default, this method calls \
-             [`Option < Accessibility >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Accessibility >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
-        <Option<Accessibility> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Accessibility>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Accessibility> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_mut_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < swc_atoms :: Atom >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
-        <Option<swc_atoms::Atom> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<swc_atoms::Atom> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < BlockStmt >`.\n\nBy default, this method calls \
-             [`Option < BlockStmt >::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < BlockStmt >::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
-        <Option<BlockStmt> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<BlockStmt>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<BlockStmt> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptCall`.\n\nBy default, this method calls \
-             [`OptCall::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`OptCall::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
-        <OptCall as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_call<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptCall,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <OptCall as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
-    #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
-             [`Option < CatchClause >::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+    #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
+             [`Option < CatchClause >::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
-        <Option<CatchClause> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<CatchClause>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<CatchClause> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptChainBase`.\n\nBy default, this method calls \
-             [`OptChainBase::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`OptChainBase::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
-        <OptChainBase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_chain_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <OptChainBase as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptChainExpr`.\n\nBy default, this method calls \
-             [`OptChainExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`OptChainExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
-        <OptChainExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_chain_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <OptChainExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Expr > >`.\n\nBy default, this method calls \
-             [`Option < Box < Expr > >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < Expr > >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
-        <Option<Box<Expr>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Expr>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<Expr>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ExprOrSpread >`.\n\nBy default, this method calls \
-             [`Option < ExprOrSpread >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < ExprOrSpread >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
-        <Option<ExprOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ExprOrSpread>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<ExprOrSpread> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Option < Vec < ExprOrSpread > >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Vec < ExprOrSpread > >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
-        <Option<Vec<ExprOrSpread>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Vec<ExprOrSpread>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             Ident >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
-        <Option<Ident> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Ident> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
-             [`Option < JSXAttrValue >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < JSXAttrValue >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
-        <Option<JSXAttrValue> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXAttrValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<JSXAttrValue> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < JSXClosingElement >`.\n\nBy default, this method calls \
-             [`Option < JSXClosingElement >::visit_mut_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < JSXClosingElement >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
-        <Option<JSXClosingElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXClosingElement>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<JSXClosingElement> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ModuleExportName >`.\n\nBy default, this method calls \
-             [`Option < ModuleExportName >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < ModuleExportName >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
-        <Option<ModuleExportName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ModuleExportName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<ModuleExportName> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < ObjectLit > >`.\n\nBy default, this method calls \
-             [`Option < Box < ObjectLit > >::visit_mut_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Box < ObjectLit > >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
-        <Option<Box<ObjectLit>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ObjectLit>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<ObjectLit>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Pat >`.\n\nBy default, this method calls [`Option < \
-             Pat >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             Pat >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
-        <Option<Pat> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Pat>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Pat> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < swc_common :: Span >`.\n\nBy default, this method \
-             calls [`Option < swc_common :: Span >::visit_mut_children_with`]. If you want to \
+             calls [`Option < swc_common :: Span >::visit_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
-        <Option<swc_common::Span> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_common::Span>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<swc_common::Span> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Stmt > >`.\n\nBy default, this method calls \
-             [`Option < Box < Stmt > >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < Stmt > >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
-        <Option<Box<Stmt>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Stmt>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<Stmt>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Str > >`.\n\nBy default, this method calls \
-             [`Option < Box < Str > >::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < Box < Str > >::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
-        <Option<Box<Str>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_str<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Str>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<Str>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TruePlusMinus >`.\n\nBy default, this method calls \
-             [`Option < TruePlusMinus >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < TruePlusMinus >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
-        <Option<TruePlusMinus> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TruePlusMinus>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<TruePlusMinus> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TsEntityName >`.\n\nBy default, this method calls \
-             [`Option < TsEntityName >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < TsEntityName >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
-        <Option<TsEntityName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsEntityName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<TsEntityName> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TsNamespaceBody >`.\n\nBy default, this method calls \
-             [`Option < TsNamespaceBody >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < TsNamespaceBody >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
-        <Option<TsNamespaceBody> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsNamespaceBody>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<TsNamespaceBody> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsType > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsType > >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < TsType > >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
-        <Option<Box<TsType>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<TsType>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeAnn > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsTypeAnn > >::visit_mut_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Box < TsTypeAnn > >::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
-        <Option<Box<TsTypeAnn>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<TsTypeAnn>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamDecl > >`.\n\nBy default, this method \
-             calls [`Option < Box < TsTypeParamDecl > >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Box < TsTypeParamDecl > >::visit_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
-        <Option<Box<TsTypeParamDecl>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamInstantiation > >`.\n\nBy default, \
              this method calls [`Option < Box < TsTypeParamInstantiation > \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_ts_type_param_instantiation(
+    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        node: &'ast Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<Self>>::visit_mut_children_with(
-            node, self,
-        )
+        < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < Self > > :: visit_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < VarDeclOrExpr >`.\n\nBy default, this method calls \
-             [`Option < VarDeclOrExpr >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < VarDeclOrExpr >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
-        <Option<VarDeclOrExpr> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<VarDeclOrExpr>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Option<VarDeclOrExpr> as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Option < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Vec < Option < ExprOrSpread > >::visit_mut_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < Option < ExprOrSpread > >::visit_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
-        <Vec<Option<ExprOrSpread>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<ExprOrSpread>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[Option<ExprOrSpread>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Option < Pat > >`.\n\nBy default, this method calls [`Vec \
-             < Option < Pat > >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             < Option < Pat > >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
-        <Vec<Option<Pat>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_opt_vec_pats<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<Pat>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[Option<Pat>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Param`.\n\nBy default, this method calls \
-             [`Param::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Param::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param) {
-        <Param as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
+        <Param as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ParamOrTsParamProp`.\n\nBy default, this method calls \
-             [`ParamOrTsParamProp::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ParamOrTsParamProp::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
-        <ParamOrTsParamProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParamOrTsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ParamOrTsParamProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ParamOrTsParamProp >`.\n\nBy default, this method calls \
-             [`Vec < ParamOrTsParamProp >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < ParamOrTsParamProp >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
-        <Vec<ParamOrTsParamProp> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ParamOrTsParamProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[ParamOrTsParamProp] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Param >`.\n\nBy default, this method calls [`Vec < Param \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
-        <Vec<Param> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Param],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[Param] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ParenExpr`.\n\nBy default, this method calls \
-             [`ParenExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ParenExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
-        <ParenExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_paren_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParenExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ParenExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Pat`.\n\nBy default, this method calls \
-             [`Pat::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Pat::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat) {
-        <Pat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
+        <Pat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Pat >`.\n\nBy default, this method calls [`Vec < Pat \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
-        <Vec<Pat> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
+        <[Pat] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PrivateMethod`.\n\nBy default, this method calls \
-             [`PrivateMethod::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`PrivateMethod::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
-        <PrivateMethod as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_private_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PrivateMethod as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PrivateName`.\n\nBy default, this method calls \
-             [`PrivateName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PrivateName::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
-        <PrivateName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_private_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PrivateName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PrivateProp`.\n\nBy default, this method calls \
-             [`PrivateProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PrivateProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
-        <PrivateProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_private_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PrivateProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Program`.\n\nBy default, this method calls \
-             [`Program::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Program::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program) {
-        <Program as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_program<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Program,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <Program as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Prop`.\n\nBy default, this method calls \
-             [`Prop::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Prop::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop) {
-        <Prop as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
+        <Prop as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PropName`.\n\nBy default, this method calls \
-             [`PropName::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PropName::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
-        <PropName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PropName as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PropOrSpread`.\n\nBy default, this method calls \
-             [`PropOrSpread::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`PropOrSpread::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
-        <PropOrSpread as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_prop_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <PropOrSpread as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             PropOrSpread >::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             PropOrSpread >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
-        <Vec<PropOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_prop_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PropOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[PropOrSpread] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
-             [`Regex::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Regex::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex) {
-        <Regex as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
+        <Regex as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `RestPat`.\n\nBy default, this method calls \
-             [`RestPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`RestPat::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
-        <RestPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_rest_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RestPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <RestPat as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ReturnStmt`.\n\nBy default, this method calls \
-             [`ReturnStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ReturnStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
-        <ReturnStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_return_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ReturnStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ReturnStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Script`.\n\nBy default, this method calls \
-             [`Script::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Script::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script) {
-        <Script as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
+        <Script as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SeqExpr`.\n\nBy default, this method calls \
-             [`SeqExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SeqExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
-        <SeqExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_seq_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SeqExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SeqExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SetterProp`.\n\nBy default, this method calls \
-             [`SetterProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SetterProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
-        <SetterProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_setter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SetterProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SimpleAssignTarget`.\n\nBy default, this method calls \
-             [`SimpleAssignTarget::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SimpleAssignTarget::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
-        <SimpleAssignTarget as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_simple_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleAssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SimpleAssignTarget as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`swc_common :: Span::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
-        <swc_common::Span as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <swc_common::Span as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SpreadElement`.\n\nBy default, this method calls \
-             [`SpreadElement::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SpreadElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
-        <SpreadElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_spread_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SpreadElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SpreadElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `StaticBlock`.\n\nBy default, this method calls \
-             [`StaticBlock::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`StaticBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
-        <StaticBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_static_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StaticBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <StaticBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Stmt`.\n\nBy default, this method calls \
-             [`Stmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Stmt::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
-        <Stmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
+        <Stmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Stmt >`.\n\nBy default, this method calls [`Vec < Stmt \
-             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
-        <Vec<Stmt> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
+        <[Stmt] as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Str::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
-        <Str as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
+        <Str as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Super`.\n\nBy default, this method calls \
-             [`Super::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Super::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super) {
-        <Super as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
+        <Super as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SuperProp`.\n\nBy default, this method calls \
-             [`SuperProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SuperProp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
-        <SuperProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_super_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SuperProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SuperPropExpr`.\n\nBy default, this method calls \
-             [`SuperPropExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SuperPropExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
-        <SuperPropExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_super_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SuperPropExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SwitchCase`.\n\nBy default, this method calls \
-             [`SwitchCase::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SwitchCase::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
-        <SwitchCase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_switch_case<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchCase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SwitchCase as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < SwitchCase >`.\n\nBy default, this method calls [`Vec < \
-             SwitchCase >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             SwitchCase >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
-        <Vec<SwitchCase> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_switch_cases<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SwitchCase],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[SwitchCase] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SwitchStmt`.\n\nBy default, this method calls \
-             [`SwitchStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SwitchStmt::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
-        <SwitchStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_switch_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <SwitchStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `swc_common :: SyntaxContext`.\n\nBy default, this method calls \
-             [`swc_common :: SyntaxContext::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`swc_common :: SyntaxContext::visit_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
-        <swc_common::SyntaxContext as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_syntax_context<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::SyntaxContext,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <swc_common::SyntaxContext as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TaggedTpl`.\n\nBy default, this method calls \
-             [`TaggedTpl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TaggedTpl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
-        <TaggedTpl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_tagged_tpl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TaggedTpl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TaggedTpl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ThisExpr`.\n\nBy default, this method calls \
-             [`ThisExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ThisExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
-        <ThisExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_this_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThisExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ThisExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ThrowStmt`.\n\nBy default, this method calls \
-             [`ThrowStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ThrowStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
-        <ThrowStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_throw_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThrowStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <ThrowStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Tpl`.\n\nBy default, this method calls \
-             [`Tpl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`Tpl::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
-        <Tpl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
+        <Tpl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TplElement`.\n\nBy default, this method calls \
-             [`TplElement::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TplElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
-        <TplElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_tpl_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TplElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TplElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < TplElement >`.\n\nBy default, this method calls [`Vec < \
-             TplElement >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             TplElement >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
-        <Vec<TplElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_tpl_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TplElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[TplElement] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TruePlusMinus`.\n\nBy default, this method calls \
-             [`TruePlusMinus::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TruePlusMinus::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
-        <TruePlusMinus as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TruePlusMinus,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TruePlusMinus as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TryStmt`.\n\nBy default, this method calls \
-             [`TryStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TryStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
-        <TryStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_try_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TryStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TryStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsArrayType`.\n\nBy default, this method calls \
-             [`TsArrayType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsArrayType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
-        <TsArrayType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_array_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsArrayType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsArrayType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsAsExpr`.\n\nBy default, this method calls \
-             [`TsAsExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsAsExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
-        <TsAsExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_as_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsAsExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsAsExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsCallSignatureDecl`.\n\nBy default, this method calls \
-             [`TsCallSignatureDecl::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsCallSignatureDecl::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
-        <TsCallSignatureDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsCallSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsCallSignatureDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConditionalType`.\n\nBy default, this method calls \
-             [`TsConditionalType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsConditionalType::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
-        <TsConditionalType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_conditional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConditionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsConditionalType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstAssertion`.\n\nBy default, this method calls \
-             [`TsConstAssertion::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsConstAssertion::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
-        <TsConstAssertion as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_const_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsConstAssertion as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstructSignatureDecl`.\n\nBy default, this method calls \
-             [`TsConstructSignatureDecl::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsConstructSignatureDecl::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
-        <TsConstructSignatureDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsConstructSignatureDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstructorType`.\n\nBy default, this method calls \
-             [`TsConstructorType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsConstructorType::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
-        <TsConstructorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsConstructorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEntityName`.\n\nBy default, this method calls \
-             [`TsEntityName::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsEntityName::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
-        <TsEntityName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEntityName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsEntityName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEnumDecl`.\n\nBy default, this method calls \
-             [`TsEnumDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsEnumDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
-        <TsEnumDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_enum_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsEnumDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsEnumMember`.\n\nBy default, this method calls \
-             [`TsEnumMember::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsEnumMember::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
-        <TsEnumMember as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_enum_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsEnumMember as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEnumMemberId`.\n\nBy default, this method calls \
-             [`TsEnumMemberId::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsEnumMemberId::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
-        <TsEnumMemberId as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMemberId,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsEnumMemberId as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsEnumMember >`.\n\nBy default, this method calls [`Vec < \
-             TsEnumMember >::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             TsEnumMember >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
-        <Vec<TsEnumMember> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_enum_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsEnumMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[TsEnumMember] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExportAssignment`.\n\nBy default, this method calls \
-             [`TsExportAssignment::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsExportAssignment::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
-        <TsExportAssignment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_export_assignment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExportAssignment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsExportAssignment as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExprWithTypeArgs`.\n\nBy default, this method calls \
-             [`TsExprWithTypeArgs::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsExprWithTypeArgs::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
-        <TsExprWithTypeArgs as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExprWithTypeArgs,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsExprWithTypeArgs as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsExprWithTypeArgs >`.\n\nBy default, this method calls \
-             [`Vec < TsExprWithTypeArgs >::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < TsExprWithTypeArgs >::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
-        <Vec<TsExprWithTypeArgs> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsExprWithTypeArgs],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[TsExprWithTypeArgs] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExternalModuleRef`.\n\nBy default, this method calls \
-             [`TsExternalModuleRef::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsExternalModuleRef::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
-        <TsExternalModuleRef as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExternalModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsExternalModuleRef as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnOrConstructorType`.\n\nBy default, this method calls \
-             [`TsFnOrConstructorType::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsFnOrConstructorType::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
-        <TsFnOrConstructorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnOrConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsFnOrConstructorType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnParam`.\n\nBy default, this method calls \
-             [`TsFnParam::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsFnParam::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
-        <TsFnParam as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_fn_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsFnParam as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < TsFnParam >`.\n\nBy default, this method calls [`Vec < \
-             TsFnParam >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             TsFnParam >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
-        <Vec<TsFnParam> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_fn_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsFnParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[TsFnParam] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnType`.\n\nBy default, this method calls \
-             [`TsFnType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsFnType::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
-        <TsFnType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_fn_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsFnType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsGetterSignature`.\n\nBy default, this method calls \
-             [`TsGetterSignature::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsGetterSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
-        <TsGetterSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_getter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsGetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsGetterSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsImportEqualsDecl`.\n\nBy default, this method calls \
-             [`TsImportEqualsDecl::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsImportEqualsDecl::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
-        <TsImportEqualsDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportEqualsDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsImportEqualsDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsImportType`.\n\nBy default, this method calls \
-             [`TsImportType::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsImportType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
-        <TsImportType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_import_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsImportType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIndexSignature`.\n\nBy default, this method calls \
-             [`TsIndexSignature::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsIndexSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
-        <TsIndexSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_index_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsIndexSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIndexedAccessType`.\n\nBy default, this method calls \
-             [`TsIndexedAccessType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsIndexedAccessType::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
-        <TsIndexedAccessType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexedAccessType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsIndexedAccessType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInferType`.\n\nBy default, this method calls \
-             [`TsInferType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsInferType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
-        <TsInferType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_infer_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInferType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsInferType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInstantiation`.\n\nBy default, this method calls \
-             [`TsInstantiation::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsInstantiation::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
-        <TsInstantiation as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsInstantiation as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInterfaceBody`.\n\nBy default, this method calls \
-             [`TsInterfaceBody::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsInterfaceBody::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
-        <TsInterfaceBody as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_interface_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsInterfaceBody as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInterfaceDecl`.\n\nBy default, this method calls \
-             [`TsInterfaceDecl::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsInterfaceDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
-        <TsInterfaceDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_interface_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsInterfaceDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIntersectionType`.\n\nBy default, this method calls \
-             [`TsIntersectionType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsIntersectionType::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
-        <TsIntersectionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsIntersectionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsKeywordType`.\n\nBy default, this method calls \
-             [`TsKeywordType::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsKeywordType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
-        <TsKeywordType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_keyword_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsKeywordType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsKeywordTypeKind`.\n\nBy default, this method calls \
-             [`TsKeywordTypeKind::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsKeywordTypeKind::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
-        <TsKeywordTypeKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordTypeKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsKeywordTypeKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsLit`.\n\nBy default, this method calls \
-             [`TsLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`TsLit::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
-        <TsLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
+        <TsLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsLitType`.\n\nBy default, this method calls \
-             [`TsLitType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsLitType::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
-        <TsLitType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsLitType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsMappedType`.\n\nBy default, this method calls \
-             [`TsMappedType::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsMappedType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
-        <TsMappedType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_mapped_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMappedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsMappedType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsMethodSignature`.\n\nBy default, this method calls \
-             [`TsMethodSignature::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsMethodSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
-        <TsMethodSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_method_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMethodSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsMethodSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleBlock`.\n\nBy default, this method calls \
-             [`TsModuleBlock::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsModuleBlock::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
-        <TsModuleBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_module_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsModuleBlock as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleDecl`.\n\nBy default, this method calls \
-             [`TsModuleDecl::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsModuleDecl::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
-        <TsModuleDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsModuleDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleName`.\n\nBy default, this method calls \
-             [`TsModuleName::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsModuleName::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
-        <TsModuleName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_module_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsModuleName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleRef`.\n\nBy default, this method calls \
-             [`TsModuleRef::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsModuleRef::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
-        <TsModuleRef as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsModuleRef as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceBody`.\n\nBy default, this method calls \
-             [`TsNamespaceBody::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsNamespaceBody::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
-        <TsNamespaceBody as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsNamespaceBody as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceDecl::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsNamespaceDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
-        <TsNamespaceDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsNamespaceDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceExportDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceExportDecl::visit_mut_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsNamespaceExportDecl::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
-        <TsNamespaceExportDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsNamespaceExportDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNonNullExpr`.\n\nBy default, this method calls \
-             [`TsNonNullExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsNonNullExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
-        <TsNonNullExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNonNullExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsNonNullExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsOptionalType`.\n\nBy default, this method calls \
-             [`TsOptionalType::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsOptionalType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
-        <TsOptionalType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_optional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsOptionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsOptionalType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParamProp`.\n\nBy default, this method calls \
-             [`TsParamProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsParamProp::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
-        <TsParamProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsParamProp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParamPropParam`.\n\nBy default, this method calls \
-             [`TsParamPropParam::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsParamPropParam::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
-        <TsParamPropParam as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamPropParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsParamPropParam as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParenthesizedType`.\n\nBy default, this method calls \
-             [`TsParenthesizedType::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsParenthesizedType::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
-        <TsParenthesizedType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParenthesizedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsParenthesizedType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsPropertySignature`.\n\nBy default, this method calls \
-             [`TsPropertySignature::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsPropertySignature::visit_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
-        <TsPropertySignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_property_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsPropertySignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsPropertySignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsQualifiedName`.\n\nBy default, this method calls \
-             [`TsQualifiedName::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsQualifiedName::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
-        <TsQualifiedName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_qualified_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsQualifiedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsQualifiedName as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsRestType`.\n\nBy default, this method calls \
-             [`TsRestType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsRestType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
-        <TsRestType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_rest_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsRestType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsRestType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsSatisfiesExpr`.\n\nBy default, this method calls \
-             [`TsSatisfiesExpr::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsSatisfiesExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
-        <TsSatisfiesExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSatisfiesExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsSatisfiesExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsSetterSignature`.\n\nBy default, this method calls \
-             [`TsSetterSignature::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsSetterSignature::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
-        <TsSetterSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_setter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsSetterSignature as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsThisType`.\n\nBy default, this method calls \
-             [`TsThisType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsThisType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
-        <TsThisType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_this_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsThisType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsThisTypeOrIdent`.\n\nBy default, this method calls \
-             [`TsThisTypeOrIdent::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsThisTypeOrIdent::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
-        <TsThisTypeOrIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisTypeOrIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsThisTypeOrIdent as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTplLitType`.\n\nBy default, this method calls \
-             [`TsTplLitType::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsTplLitType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
-        <TsTplLitType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTplLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTplLitType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTupleElement`.\n\nBy default, this method calls \
-             [`TsTupleElement::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsTupleElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
-        <TsTupleElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_tuple_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTupleElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTupleElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTupleElement >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             < TsTupleElement >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
-        <Vec<TsTupleElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTupleElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[TsTupleElement] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTupleType`.\n\nBy default, this method calls \
-             [`TsTupleType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTupleType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
-        <TsTupleType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_tuple_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTupleType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsType`.\n\nBy default, this method calls \
-             [`TsType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             [`TsType::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
-        <TsType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsType as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeAliasDecl`.\n\nBy default, this method calls \
-             [`TsTypeAliasDecl::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeAliasDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
-        <TsTypeAliasDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAliasDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeAliasDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeAnn`.\n\nBy default, this method calls \
-             [`TsTypeAnn::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeAnn::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
-        <TsTypeAnn as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAnn,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeAnn as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeAssertion`.\n\nBy default, this method calls \
-             [`TsTypeAssertion::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeAssertion::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
-        <TsTypeAssertion as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeAssertion as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeElement`.\n\nBy default, this method calls \
-             [`TsTypeElement::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsTypeElement::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
-        <TsTypeElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeElement as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTypeElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTypeElement >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             < TsTypeElement >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
-        <Vec<TsTypeElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[TsTypeElement] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeLit`.\n\nBy default, this method calls \
-             [`TsTypeLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeLit::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
-        <TsTypeLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeLit as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeOperator`.\n\nBy default, this method calls \
-             [`TsTypeOperator::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsTypeOperator::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
-        <TsTypeOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeOperator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeOperatorOp`.\n\nBy default, this method calls \
-             [`TsTypeOperatorOp::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeOperatorOp::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
-        <TsTypeOperatorOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperatorOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeOperatorOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParam`.\n\nBy default, this method calls \
-             [`TsTypeParam::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeParam::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
-        <TsTypeParam as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeParam as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParamDecl`.\n\nBy default, this method calls \
-             [`TsTypeParamDecl::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeParamDecl::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
-        <TsTypeParamDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeParamDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParamInstantiation`.\n\nBy default, this method calls \
-             [`TsTypeParamInstantiation::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypeParamInstantiation::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
-        <TsTypeParamInstantiation as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeParamInstantiation as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTypeParam >`.\n\nBy default, this method calls [`Vec < \
-             TsTypeParam >::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             TsTypeParam >::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
-        <Vec<TsTypeParam> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[TsTypeParam] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypePredicate`.\n\nBy default, this method calls \
-             [`TsTypePredicate::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypePredicate::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
-        <TsTypePredicate as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_predicate<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypePredicate,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypePredicate as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeQuery`.\n\nBy default, this method calls \
-             [`TsTypeQuery::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeQuery::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
-        <TsTypeQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeQuery as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeQueryExpr`.\n\nBy default, this method calls \
-             [`TsTypeQueryExpr::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeQueryExpr::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
-        <TsTypeQueryExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQueryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeQueryExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeRef`.\n\nBy default, this method calls \
-             [`TsTypeRef::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeRef::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
-        <TsTypeRef as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_type_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsTypeRef as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Box < TsType > >`.\n\nBy default, this method calls [`Vec \
-             < Box < TsType > >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             < Box < TsType > >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
-        <Vec<Box<TsType>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<TsType>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[Box<TsType>] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsUnionOrIntersectionType`.\n\nBy default, this method calls \
-             [`TsUnionOrIntersectionType::visit_mut_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsUnionOrIntersectionType::visit_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
-        <TsUnionOrIntersectionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionOrIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsUnionOrIntersectionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsUnionType`.\n\nBy default, this method calls \
-             [`TsUnionType::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsUnionType::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
-        <TsUnionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_ts_union_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <TsUnionType as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UnaryExpr`.\n\nBy default, this method calls \
-             [`UnaryExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UnaryExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
-        <UnaryExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_unary_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UnaryExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UnaryOp`.\n\nBy default, this method calls \
-             [`UnaryOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UnaryOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
-        <UnaryOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_unary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UnaryOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UpdateExpr`.\n\nBy default, this method calls \
-             [`UpdateExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UpdateExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
-        <UpdateExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_update_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UpdateExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UpdateOp`.\n\nBy default, this method calls \
-             [`UpdateOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UpdateOp::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
-        <UpdateOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_update_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UpdateOp as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UsingDecl`.\n\nBy default, this method calls \
-             [`UsingDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UsingDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
-        <UsingDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_using_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UsingDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <UsingDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `VarDecl`.\n\nBy default, this method calls \
-             [`VarDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`VarDecl::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
-        <VarDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_var_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <VarDecl as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `VarDeclKind`.\n\nBy default, this method calls \
-             [`VarDeclKind::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`VarDeclKind::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
-        <VarDeclKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_var_decl_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <VarDeclKind as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `VarDeclOrExpr`.\n\nBy default, this method calls \
-             [`VarDeclOrExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`VarDeclOrExpr::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
-        <VarDeclOrExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <VarDeclOrExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `VarDeclarator`.\n\nBy default, this method calls \
-             [`VarDeclarator::visit_mut_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`VarDeclarator::visit_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
-        <VarDeclarator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_var_declarator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclarator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <VarDeclarator as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < VarDeclarator >`.\n\nBy default, this method calls [`Vec \
-             < VarDeclarator >::visit_mut_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             < VarDeclarator >::visit_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
-        <Vec<VarDeclarator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_var_declarators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [VarDeclarator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <[VarDeclarator] as VisitWithAstPath<Self>>::visit_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `WhileStmt`.\n\nBy default, this method calls \
-             [`WhileStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`WhileStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
-        <WhileStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <WhileStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `WithStmt`.\n\nBy default, this method calls \
-             [`WithStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`WithStmt::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
-        <WithStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_with_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WithStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <WithStmt as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `YieldExpr`.\n\nBy default, this method calls \
-             [`YieldExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`YieldExpr::visit_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
-        <YieldExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
+    fn visit_yield_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast YieldExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <YieldExpr as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
 }
-impl<V> VisitMut for &mut V
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitAstPath for &mut V
 where
-    V: ?Sized + VisitMut,
+    V: ?Sized + VisitAstPath,
 {
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
-        <V as VisitMut>::visit_mut_accessibility(&mut **self, node)
+    fn visit_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Accessibility,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
-        <V as VisitMut>::visit_mut_array_lit(&mut **self, node)
+    fn visit_array_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_array_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
-        <V as VisitMut>::visit_mut_array_pat(&mut **self, node)
+    fn visit_array_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_array_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
-        <V as VisitMut>::visit_mut_arrow_expr(&mut **self, node)
+    fn visit_arrow_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrowExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_arrow_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
-        <V as VisitMut>::visit_mut_assign_expr(&mut **self, node)
+    fn visit_assign_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
-        <V as VisitMut>::visit_mut_assign_op(&mut **self, node)
+    fn visit_assign_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
-        <V as VisitMut>::visit_mut_assign_pat(&mut **self, node)
+    fn visit_assign_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
-        <V as VisitMut>::visit_mut_assign_pat_prop(&mut **self, node)
+    fn visit_assign_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
-        <V as VisitMut>::visit_mut_assign_prop(&mut **self, node)
+    fn visit_assign_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
-        <V as VisitMut>::visit_mut_assign_target(&mut **self, node)
+    fn visit_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
-        <V as VisitMut>::visit_mut_assign_target_pat(&mut **self, node)
+    fn visit_assign_target_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTargetPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_target_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
-        <V as VisitMut>::visit_mut_atom(&mut **self, node)
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
-        <V as VisitMut>::visit_mut_auto_accessor(&mut **self, node)
+    fn visit_auto_accessor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AutoAccessor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_auto_accessor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
-        <V as VisitMut>::visit_mut_await_expr(&mut **self, node)
+    fn visit_await_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AwaitExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_await_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
-        <V as VisitMut>::visit_mut_big_int(&mut **self, node)
+    fn visit_big_int<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigInt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_big_int(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
-        <V as VisitMut>::visit_mut_big_int_value(&mut **self, node)
+    fn visit_big_int_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigIntValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_big_int_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
-        <V as VisitMut>::visit_mut_bin_expr(&mut **self, node)
+    fn visit_bin_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_bin_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
-        <V as VisitMut>::visit_mut_binary_op(&mut **self, node)
+    fn visit_binary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_binary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
-        <V as VisitMut>::visit_mut_binding_ident(&mut **self, node)
+    fn visit_binding_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BindingIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_binding_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
-        <V as VisitMut>::visit_mut_block_stmt(&mut **self, node)
+    fn visit_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
-        <V as VisitMut>::visit_mut_block_stmt_or_expr(&mut **self, node)
+    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmtOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_block_stmt_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool) {
-        <V as VisitMut>::visit_mut_bool(&mut **self, node)
+    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_bool(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
-        <V as VisitMut>::visit_mut_break_stmt(&mut **self, node)
+    fn visit_break_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BreakStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_break_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
-        <V as VisitMut>::visit_mut_call_expr(&mut **self, node)
+    fn visit_call_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CallExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_call_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee) {
-        <V as VisitMut>::visit_mut_callee(&mut **self, node)
+    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_callee(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
-        <V as VisitMut>::visit_mut_catch_clause(&mut **self, node)
+    fn visit_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CatchClause,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class) {
-        <V as VisitMut>::visit_mut_class(&mut **self, node)
+    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_class(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
-        <V as VisitMut>::visit_mut_class_decl(&mut **self, node)
+    fn visit_class_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
-        <V as VisitMut>::visit_mut_class_expr(&mut **self, node)
+    fn visit_class_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
-        <V as VisitMut>::visit_mut_class_member(&mut **self, node)
+    fn visit_class_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
-        <V as VisitMut>::visit_mut_class_members(&mut **self, node)
+    fn visit_class_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ClassMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
-        <V as VisitMut>::visit_mut_class_method(&mut **self, node)
+    fn visit_class_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
-        <V as VisitMut>::visit_mut_class_prop(&mut **self, node)
+    fn visit_class_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
-        <V as VisitMut>::visit_mut_computed_prop_name(&mut **self, node)
+    fn visit_computed_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComputedPropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_computed_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
-        <V as VisitMut>::visit_mut_cond_expr(&mut **self, node)
+    fn visit_cond_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CondExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_cond_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
-        <V as VisitMut>::visit_mut_constructor(&mut **self, node)
+    fn visit_constructor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Constructor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_constructor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
-        <V as VisitMut>::visit_mut_continue_stmt(&mut **self, node)
+    fn visit_continue_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContinueStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_continue_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
-        <V as VisitMut>::visit_mut_debugger_stmt(&mut **self, node)
+    fn visit_debugger_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DebuggerStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_debugger_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl) {
-        <V as VisitMut>::visit_mut_decl(&mut **self, node)
+    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
-        <V as VisitMut>::visit_mut_decorator(&mut **self, node)
+    fn visit_decorator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Decorator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_decorator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
-        <V as VisitMut>::visit_mut_decorators(&mut **self, node)
+    fn visit_decorators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Decorator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_decorators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
-        <V as VisitMut>::visit_mut_default_decl(&mut **self, node)
+    fn visit_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
-        <V as VisitMut>::visit_mut_do_while_stmt(&mut **self, node)
+    fn visit_do_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DoWhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_do_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
-        <V as VisitMut>::visit_mut_empty_stmt(&mut **self, node)
+    fn visit_empty_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EmptyStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_empty_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
-        <V as VisitMut>::visit_mut_es_version(&mut **self, node)
+    fn visit_es_version<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EsVersion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_es_version(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
-        <V as VisitMut>::visit_mut_export_all(&mut **self, node)
+    fn visit_export_all<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportAll,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_all(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
-        <V as VisitMut>::visit_mut_export_decl(&mut **self, node)
+    fn visit_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
-        <V as VisitMut>::visit_mut_export_default_decl(&mut **self, node)
+    fn visit_export_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
-        <V as VisitMut>::visit_mut_export_default_expr(&mut **self, node)
+    fn visit_export_default_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
-        <V as VisitMut>::visit_mut_export_default_specifier(&mut **self, node)
+    fn visit_export_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
-        <V as VisitMut>::visit_mut_export_named_specifier(&mut **self, node)
+    fn visit_export_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
-        <V as VisitMut>::visit_mut_export_namespace_specifier(&mut **self, node)
+    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamespaceSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_namespace_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
-        <V as VisitMut>::visit_mut_export_specifier(&mut **self, node)
+    fn visit_export_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
-        <V as VisitMut>::visit_mut_export_specifiers(&mut **self, node)
+    fn visit_export_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr) {
-        <V as VisitMut>::visit_mut_expr(&mut **self, node)
+    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
-        <V as VisitMut>::visit_mut_expr_or_spread(&mut **self, node)
+    fn visit_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
-        <V as VisitMut>::visit_mut_expr_or_spreads(&mut **self, node)
+    fn visit_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExprOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
-        <V as VisitMut>::visit_mut_expr_stmt(&mut **self, node)
+    fn visit_expr_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
-        <V as VisitMut>::visit_mut_exprs(&mut **self, node)
+    fn visit_exprs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<Expr>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_exprs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
-        <V as VisitMut>::visit_mut_fn_decl(&mut **self, node)
+    fn visit_fn_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_fn_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
-        <V as VisitMut>::visit_mut_fn_expr(&mut **self, node)
+    fn visit_fn_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_fn_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
-        <V as VisitMut>::visit_mut_for_head(&mut **self, node)
+    fn visit_for_head<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForHead,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_head(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
-        <V as VisitMut>::visit_mut_for_in_stmt(&mut **self, node)
+    fn visit_for_in_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForInStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_in_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
-        <V as VisitMut>::visit_mut_for_of_stmt(&mut **self, node)
+    fn visit_for_of_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForOfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_of_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
-        <V as VisitMut>::visit_mut_for_stmt(&mut **self, node)
+    fn visit_for_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
-        <V as VisitMut>::visit_mut_function(&mut **self, node)
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
-        <V as VisitMut>::visit_mut_getter_prop(&mut **self, node)
+    fn visit_getter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast GetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_getter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
-        <V as VisitMut>::visit_mut_ident(&mut **self, node)
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
-        <V as VisitMut>::visit_mut_ident_name(&mut **self, node)
+    fn visit_ident_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdentName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ident_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
-        <V as VisitMut>::visit_mut_if_stmt(&mut **self, node)
+    fn visit_if_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_if_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import) {
-        <V as VisitMut>::visit_mut_import(&mut **self, node)
+    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_import(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
-        <V as VisitMut>::visit_mut_import_decl(&mut **self, node)
+    fn visit_import_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
-        <V as VisitMut>::visit_mut_import_default_specifier(&mut **self, node)
+    fn visit_import_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
-        <V as VisitMut>::visit_mut_import_named_specifier(&mut **self, node)
+    fn visit_import_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
-        <V as VisitMut>::visit_mut_import_phase(&mut **self, node)
+    fn visit_import_phase<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPhase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_phase(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
-        <V as VisitMut>::visit_mut_import_specifier(&mut **self, node)
+    fn visit_import_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
-        <V as VisitMut>::visit_mut_import_specifiers(&mut **self, node)
+    fn visit_import_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
-        <V as VisitMut>::visit_mut_import_star_as_specifier(&mut **self, node)
+    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportStarAsSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_star_as_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
-        <V as VisitMut>::visit_mut_import_with(&mut **self, node)
+    fn visit_import_with<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWith,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
-        <V as VisitMut>::visit_mut_import_with_item(&mut **self, node)
+    fn visit_import_with_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWithItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
-        <V as VisitMut>::visit_mut_import_with_items(&mut **self, node)
+    fn visit_import_with_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportWithItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
-        <V as VisitMut>::visit_mut_invalid(&mut **self, node)
+    fn visit_invalid<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Invalid,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_invalid(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
-        <V as VisitMut>::visit_mut_jsx_attr(&mut **self, node)
+    fn visit_jsx_attr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
-        <V as VisitMut>::visit_mut_jsx_attr_name(&mut **self, node)
+    fn visit_jsx_attr_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
-        <V as VisitMut>::visit_mut_jsx_attr_or_spread(&mut **self, node)
+    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
-        <V as VisitMut>::visit_mut_jsx_attr_or_spreads(&mut **self, node)
+    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXAttrOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
-        <V as VisitMut>::visit_mut_jsx_attr_value(&mut **self, node)
+    fn visit_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
-        <V as VisitMut>::visit_mut_jsx_closing_element(&mut **self, node)
+    fn visit_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
-        <V as VisitMut>::visit_mut_jsx_closing_fragment(&mut **self, node)
+    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_closing_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
-        <V as VisitMut>::visit_mut_jsx_element(&mut **self, node)
+    fn visit_jsx_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
-        <V as VisitMut>::visit_mut_jsx_element_child(&mut **self, node)
+    fn visit_jsx_element_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
-        <V as VisitMut>::visit_mut_jsx_element_childs(&mut **self, node)
+    fn visit_jsx_element_childs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXElementChild],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_childs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
-        <V as VisitMut>::visit_mut_jsx_element_name(&mut **self, node)
+    fn visit_jsx_element_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
-        <V as VisitMut>::visit_mut_jsx_empty_expr(&mut **self, node)
+    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXEmptyExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_empty_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
-        <V as VisitMut>::visit_mut_jsx_expr(&mut **self, node)
+    fn visit_jsx_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
-        <V as VisitMut>::visit_mut_jsx_expr_container(&mut **self, node)
+    fn visit_jsx_expr_container<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExprContainer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_expr_container(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
-        <V as VisitMut>::visit_mut_jsx_fragment(&mut **self, node)
+    fn visit_jsx_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
-        <V as VisitMut>::visit_mut_jsx_member_expr(&mut **self, node)
+    fn visit_jsx_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXMemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
-        <V as VisitMut>::visit_mut_jsx_namespaced_name(&mut **self, node)
+    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXNamespacedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_namespaced_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
-        <V as VisitMut>::visit_mut_jsx_object(&mut **self, node)
+    fn visit_jsx_object<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXObject,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_object(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
-        <V as VisitMut>::visit_mut_jsx_opening_element(&mut **self, node)
+    fn visit_jsx_opening_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_opening_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
-        <V as VisitMut>::visit_mut_jsx_opening_fragment(&mut **self, node)
+    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_opening_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
-        <V as VisitMut>::visit_mut_jsx_spread_child(&mut **self, node)
+    fn visit_jsx_spread_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXSpreadChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_spread_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
-        <V as VisitMut>::visit_mut_jsx_text(&mut **self, node)
+    fn visit_jsx_text<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXText,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_text(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key) {
-        <V as VisitMut>::visit_mut_key(&mut **self, node)
+    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_key(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
-        <V as VisitMut>::visit_mut_key_value_pat_prop(&mut **self, node)
+    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValuePatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_key_value_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
-        <V as VisitMut>::visit_mut_key_value_prop(&mut **self, node)
+    fn visit_key_value_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValueProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_key_value_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
-        <V as VisitMut>::visit_mut_labeled_stmt(&mut **self, node)
+    fn visit_labeled_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LabeledStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_labeled_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit) {
-        <V as VisitMut>::visit_mut_lit(&mut **self, node)
+    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
-        <V as VisitMut>::visit_mut_member_expr(&mut **self, node)
+    fn visit_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
-        <V as VisitMut>::visit_mut_member_prop(&mut **self, node)
+    fn visit_member_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_member_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
-        <V as VisitMut>::visit_mut_meta_prop_expr(&mut **self, node)
+    fn visit_meta_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_meta_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
-        <V as VisitMut>::visit_mut_meta_prop_kind(&mut **self, node)
+    fn visit_meta_prop_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_meta_prop_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
-        <V as VisitMut>::visit_mut_method_kind(&mut **self, node)
+    fn visit_method_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_method_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
-        <V as VisitMut>::visit_mut_method_prop(&mut **self, node)
+    fn visit_method_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_method_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module) {
-        <V as VisitMut>::visit_mut_module(&mut **self, node)
+    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_module(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
-        <V as VisitMut>::visit_mut_module_decl(&mut **self, node)
+    fn visit_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
-        <V as VisitMut>::visit_mut_module_export_name(&mut **self, node)
+    fn visit_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleExportName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
-        <V as VisitMut>::visit_mut_module_item(&mut **self, node)
+    fn visit_module_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
-        <V as VisitMut>::visit_mut_module_items(&mut **self, node)
+    fn visit_module_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ModuleItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
-        <V as VisitMut>::visit_mut_named_export(&mut **self, node)
+    fn visit_named_export<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedExport,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_named_export(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
-        <V as VisitMut>::visit_mut_new_expr(&mut **self, node)
+    fn visit_new_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NewExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_new_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null) {
-        <V as VisitMut>::visit_mut_null(&mut **self, node)
+    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_null(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
-        <V as VisitMut>::visit_mut_number(&mut **self, node)
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
-        <V as VisitMut>::visit_mut_object_lit(&mut **self, node)
+    fn visit_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
-        <V as VisitMut>::visit_mut_object_pat(&mut **self, node)
+    fn visit_object_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
-        <V as VisitMut>::visit_mut_object_pat_prop(&mut **self, node)
+    fn visit_object_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
-        <V as VisitMut>::visit_mut_object_pat_props(&mut **self, node)
+    fn visit_object_pat_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ObjectPatProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
-        <V as VisitMut>::visit_mut_opt_accessibility(&mut **self, node)
+    fn visit_opt_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Accessibility>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
-        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
-        <V as VisitMut>::visit_mut_opt_block_stmt(&mut **self, node)
+    fn visit_opt_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<BlockStmt>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
-        <V as VisitMut>::visit_mut_opt_call(&mut **self, node)
+    fn visit_opt_call<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptCall,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_call(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
-        <V as VisitMut>::visit_mut_opt_catch_clause(&mut **self, node)
+    fn visit_opt_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<CatchClause>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
-        <V as VisitMut>::visit_mut_opt_chain_base(&mut **self, node)
+    fn visit_opt_chain_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_chain_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
-        <V as VisitMut>::visit_mut_opt_chain_expr(&mut **self, node)
+    fn visit_opt_chain_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_chain_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
-        <V as VisitMut>::visit_mut_opt_expr(&mut **self, node)
+    fn visit_opt_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Expr>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
-        <V as VisitMut>::visit_mut_opt_expr_or_spread(&mut **self, node)
+    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ExprOrSpread>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
-        <V as VisitMut>::visit_mut_opt_expr_or_spreads(&mut **self, node)
+    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
-        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
-        <V as VisitMut>::visit_mut_opt_jsx_attr_value(&mut **self, node)
+    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXAttrValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
-        <V as VisitMut>::visit_mut_opt_jsx_closing_element(&mut **self, node)
+    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXClosingElement>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
-        <V as VisitMut>::visit_mut_opt_module_export_name(&mut **self, node)
+    fn visit_opt_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ModuleExportName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
-        <V as VisitMut>::visit_mut_opt_object_lit(&mut **self, node)
+    fn visit_opt_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ObjectLit>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
-        <V as VisitMut>::visit_mut_opt_pat(&mut **self, node)
+    fn visit_opt_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Pat>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
-        <V as VisitMut>::visit_mut_opt_span(&mut **self, node)
+    fn visit_opt_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_common::Span>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
-        <V as VisitMut>::visit_mut_opt_stmt(&mut **self, node)
+    fn visit_opt_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Stmt>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
-        <V as VisitMut>::visit_mut_opt_str(&mut **self, node)
+    fn visit_opt_str<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Str>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
-        <V as VisitMut>::visit_mut_opt_true_plus_minus(&mut **self, node)
+    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TruePlusMinus>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
-        <V as VisitMut>::visit_mut_opt_ts_entity_name(&mut **self, node)
+    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsEntityName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
-        <V as VisitMut>::visit_mut_opt_ts_namespace_body(&mut **self, node)
+    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsNamespaceBody>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
-        <V as VisitMut>::visit_mut_opt_ts_type(&mut **self, node)
+    fn visit_opt_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
-        <V as VisitMut>::visit_mut_opt_ts_type_ann(&mut **self, node)
+    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
-        <V as VisitMut>::visit_mut_opt_ts_type_param_decl(&mut **self, node)
+    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_instantiation(
+    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        node: &'ast Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
-        <V as VisitMut>::visit_mut_opt_var_decl_or_expr(&mut **self, node)
+    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<VarDeclOrExpr>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
-        <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node)
+    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<ExprOrSpread>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
-        <V as VisitMut>::visit_mut_opt_vec_pats(&mut **self, node)
+    fn visit_opt_vec_pats<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<Pat>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_vec_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param) {
-        <V as VisitMut>::visit_mut_param(&mut **self, node)
+    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
-        <V as VisitMut>::visit_mut_param_or_ts_param_prop(&mut **self, node)
+    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParamOrTsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_param_or_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
-        <V as VisitMut>::visit_mut_param_or_ts_param_props(&mut **self, node)
+    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ParamOrTsParamProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_param_or_ts_param_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
-        <V as VisitMut>::visit_mut_params(&mut **self, node)
+    fn visit_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Param],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
-        <V as VisitMut>::visit_mut_paren_expr(&mut **self, node)
+    fn visit_paren_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParenExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_paren_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat) {
-        <V as VisitMut>::visit_mut_pat(&mut **self, node)
+    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
-        <V as VisitMut>::visit_mut_pats(&mut **self, node)
+    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
-        <V as VisitMut>::visit_mut_private_method(&mut **self, node)
+    fn visit_private_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
-        <V as VisitMut>::visit_mut_private_name(&mut **self, node)
+    fn visit_private_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
-        <V as VisitMut>::visit_mut_private_prop(&mut **self, node)
+    fn visit_private_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program) {
-        <V as VisitMut>::visit_mut_program(&mut **self, node)
+    fn visit_program<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Program,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_program(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop) {
-        <V as VisitMut>::visit_mut_prop(&mut **self, node)
+    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
-        <V as VisitMut>::visit_mut_prop_name(&mut **self, node)
+    fn visit_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
-        <V as VisitMut>::visit_mut_prop_or_spread(&mut **self, node)
+    fn visit_prop_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
-        <V as VisitMut>::visit_mut_prop_or_spreads(&mut **self, node)
+    fn visit_prop_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PropOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex) {
-        <V as VisitMut>::visit_mut_regex(&mut **self, node)
+    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_regex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
-        <V as VisitMut>::visit_mut_rest_pat(&mut **self, node)
+    fn visit_rest_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RestPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_rest_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
-        <V as VisitMut>::visit_mut_return_stmt(&mut **self, node)
+    fn visit_return_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ReturnStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_return_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script) {
-        <V as VisitMut>::visit_mut_script(&mut **self, node)
+    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_script(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
-        <V as VisitMut>::visit_mut_seq_expr(&mut **self, node)
+    fn visit_seq_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SeqExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_seq_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
-        <V as VisitMut>::visit_mut_setter_prop(&mut **self, node)
+    fn visit_setter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_setter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
-        <V as VisitMut>::visit_mut_simple_assign_target(&mut **self, node)
+    fn visit_simple_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleAssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_simple_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
-        <V as VisitMut>::visit_mut_span(&mut **self, node)
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
-        <V as VisitMut>::visit_mut_spread_element(&mut **self, node)
+    fn visit_spread_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SpreadElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_spread_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
-        <V as VisitMut>::visit_mut_static_block(&mut **self, node)
+    fn visit_static_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StaticBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_static_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
-        <V as VisitMut>::visit_mut_stmt(&mut **self, node)
+    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
-        <V as VisitMut>::visit_mut_stmts(&mut **self, node)
+    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_stmts(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
-        <V as VisitMut>::visit_mut_str(&mut **self, node)
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super) {
-        <V as VisitMut>::visit_mut_super(&mut **self, node)
+    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_super(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
-        <V as VisitMut>::visit_mut_super_prop(&mut **self, node)
+    fn visit_super_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_super_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
-        <V as VisitMut>::visit_mut_super_prop_expr(&mut **self, node)
+    fn visit_super_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_super_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
-        <V as VisitMut>::visit_mut_switch_case(&mut **self, node)
+    fn visit_switch_case<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchCase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_case(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
-        <V as VisitMut>::visit_mut_switch_cases(&mut **self, node)
+    fn visit_switch_cases<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SwitchCase],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_cases(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
-        <V as VisitMut>::visit_mut_switch_stmt(&mut **self, node)
+    fn visit_switch_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
-        <V as VisitMut>::visit_mut_syntax_context(&mut **self, node)
+    fn visit_syntax_context<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::SyntaxContext,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_syntax_context(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
-        <V as VisitMut>::visit_mut_tagged_tpl(&mut **self, node)
+    fn visit_tagged_tpl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TaggedTpl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tagged_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
-        <V as VisitMut>::visit_mut_this_expr(&mut **self, node)
+    fn visit_this_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThisExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_this_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
-        <V as VisitMut>::visit_mut_throw_stmt(&mut **self, node)
+    fn visit_throw_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThrowStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_throw_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
-        <V as VisitMut>::visit_mut_tpl(&mut **self, node)
+    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
-        <V as VisitMut>::visit_mut_tpl_element(&mut **self, node)
+    fn visit_tpl_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TplElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tpl_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
-        <V as VisitMut>::visit_mut_tpl_elements(&mut **self, node)
+    fn visit_tpl_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TplElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tpl_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
-        <V as VisitMut>::visit_mut_true_plus_minus(&mut **self, node)
+    fn visit_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TruePlusMinus,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
-        <V as VisitMut>::visit_mut_try_stmt(&mut **self, node)
+    fn visit_try_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TryStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_try_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
-        <V as VisitMut>::visit_mut_ts_array_type(&mut **self, node)
+    fn visit_ts_array_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsArrayType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_array_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
-        <V as VisitMut>::visit_mut_ts_as_expr(&mut **self, node)
+    fn visit_ts_as_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsAsExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_as_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
-        <V as VisitMut>::visit_mut_ts_call_signature_decl(&mut **self, node)
+    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsCallSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_call_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
-        <V as VisitMut>::visit_mut_ts_conditional_type(&mut **self, node)
+    fn visit_ts_conditional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConditionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_conditional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
-        <V as VisitMut>::visit_mut_ts_const_assertion(&mut **self, node)
+    fn visit_ts_const_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_const_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
-        <V as VisitMut>::visit_mut_ts_construct_signature_decl(&mut **self, node)
+    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_construct_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
-        <V as VisitMut>::visit_mut_ts_constructor_type(&mut **self, node)
+    fn visit_ts_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
-        <V as VisitMut>::visit_mut_ts_entity_name(&mut **self, node)
+    fn visit_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEntityName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
-        <V as VisitMut>::visit_mut_ts_enum_decl(&mut **self, node)
+    fn visit_ts_enum_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
-        <V as VisitMut>::visit_mut_ts_enum_member(&mut **self, node)
+    fn visit_ts_enum_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
-        <V as VisitMut>::visit_mut_ts_enum_member_id(&mut **self, node)
+    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMemberId,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_member_id(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
-        <V as VisitMut>::visit_mut_ts_enum_members(&mut **self, node)
+    fn visit_ts_enum_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsEnumMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
-        <V as VisitMut>::visit_mut_ts_export_assignment(&mut **self, node)
+    fn visit_ts_export_assignment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExportAssignment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_export_assignment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
-        <V as VisitMut>::visit_mut_ts_expr_with_type_args(&mut **self, node)
+    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExprWithTypeArgs,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_expr_with_type_args(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
-        <V as VisitMut>::visit_mut_ts_expr_with_type_argss(&mut **self, node)
+    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsExprWithTypeArgs],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_expr_with_type_argss(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
-        <V as VisitMut>::visit_mut_ts_external_module_ref(&mut **self, node)
+    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExternalModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_external_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
-        <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(&mut **self, node)
+    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnOrConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
-        <V as VisitMut>::visit_mut_ts_fn_param(&mut **self, node)
+    fn visit_ts_fn_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
-        <V as VisitMut>::visit_mut_ts_fn_params(&mut **self, node)
+    fn visit_ts_fn_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsFnParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
-        <V as VisitMut>::visit_mut_ts_fn_type(&mut **self, node)
+    fn visit_ts_fn_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
-        <V as VisitMut>::visit_mut_ts_getter_signature(&mut **self, node)
+    fn visit_ts_getter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsGetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_getter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
-        <V as VisitMut>::visit_mut_ts_import_equals_decl(&mut **self, node)
+    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportEqualsDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_import_equals_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
-        <V as VisitMut>::visit_mut_ts_import_type(&mut **self, node)
+    fn visit_ts_import_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_import_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
-        <V as VisitMut>::visit_mut_ts_index_signature(&mut **self, node)
+    fn visit_ts_index_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_index_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
-        <V as VisitMut>::visit_mut_ts_indexed_access_type(&mut **self, node)
+    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexedAccessType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_indexed_access_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
-        <V as VisitMut>::visit_mut_ts_infer_type(&mut **self, node)
+    fn visit_ts_infer_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInferType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_infer_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
-        <V as VisitMut>::visit_mut_ts_instantiation(&mut **self, node)
+    fn visit_ts_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
-        <V as VisitMut>::visit_mut_ts_interface_body(&mut **self, node)
+    fn visit_ts_interface_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_interface_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
-        <V as VisitMut>::visit_mut_ts_interface_decl(&mut **self, node)
+    fn visit_ts_interface_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_interface_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
-        <V as VisitMut>::visit_mut_ts_intersection_type(&mut **self, node)
+    fn visit_ts_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
-        <V as VisitMut>::visit_mut_ts_keyword_type(&mut **self, node)
+    fn visit_ts_keyword_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_keyword_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
-        <V as VisitMut>::visit_mut_ts_keyword_type_kind(&mut **self, node)
+    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordTypeKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_keyword_type_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
-        <V as VisitMut>::visit_mut_ts_lit(&mut **self, node)
+    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ts_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
-        <V as VisitMut>::visit_mut_ts_lit_type(&mut **self, node)
+    fn visit_ts_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
-        <V as VisitMut>::visit_mut_ts_mapped_type(&mut **self, node)
+    fn visit_ts_mapped_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMappedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_mapped_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
-        <V as VisitMut>::visit_mut_ts_method_signature(&mut **self, node)
+    fn visit_ts_method_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMethodSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_method_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
-        <V as VisitMut>::visit_mut_ts_module_block(&mut **self, node)
+    fn visit_ts_module_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
-        <V as VisitMut>::visit_mut_ts_module_decl(&mut **self, node)
+    fn visit_ts_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
-        <V as VisitMut>::visit_mut_ts_module_name(&mut **self, node)
+    fn visit_ts_module_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
-        <V as VisitMut>::visit_mut_ts_module_ref(&mut **self, node)
+    fn visit_ts_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
-        <V as VisitMut>::visit_mut_ts_namespace_body(&mut **self, node)
+    fn visit_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
-        <V as VisitMut>::visit_mut_ts_namespace_decl(&mut **self, node)
+    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
-        <V as VisitMut>::visit_mut_ts_namespace_export_decl(&mut **self, node)
+    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
-        <V as VisitMut>::visit_mut_ts_non_null_expr(&mut **self, node)
+    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNonNullExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_non_null_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
-        <V as VisitMut>::visit_mut_ts_optional_type(&mut **self, node)
+    fn visit_ts_optional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsOptionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_optional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
-        <V as VisitMut>::visit_mut_ts_param_prop(&mut **self, node)
+    fn visit_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
-        <V as VisitMut>::visit_mut_ts_param_prop_param(&mut **self, node)
+    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamPropParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_param_prop_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
-        <V as VisitMut>::visit_mut_ts_parenthesized_type(&mut **self, node)
+    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParenthesizedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_parenthesized_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
-        <V as VisitMut>::visit_mut_ts_property_signature(&mut **self, node)
+    fn visit_ts_property_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsPropertySignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_property_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
-        <V as VisitMut>::visit_mut_ts_qualified_name(&mut **self, node)
+    fn visit_ts_qualified_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsQualifiedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_qualified_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
-        <V as VisitMut>::visit_mut_ts_rest_type(&mut **self, node)
+    fn visit_ts_rest_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsRestType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_rest_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
-        <V as VisitMut>::visit_mut_ts_satisfies_expr(&mut **self, node)
+    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSatisfiesExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_satisfies_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
-        <V as VisitMut>::visit_mut_ts_setter_signature(&mut **self, node)
+    fn visit_ts_setter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_setter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
-        <V as VisitMut>::visit_mut_ts_this_type(&mut **self, node)
+    fn visit_ts_this_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_this_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
-        <V as VisitMut>::visit_mut_ts_this_type_or_ident(&mut **self, node)
+    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisTypeOrIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_this_type_or_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
-        <V as VisitMut>::visit_mut_ts_tpl_lit_type(&mut **self, node)
+    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTplLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tpl_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
-        <V as VisitMut>::visit_mut_ts_tuple_element(&mut **self, node)
+    fn visit_ts_tuple_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
-        <V as VisitMut>::visit_mut_ts_tuple_elements(&mut **self, node)
+    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTupleElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
-        <V as VisitMut>::visit_mut_ts_tuple_type(&mut **self, node)
+    fn visit_ts_tuple_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
-        <V as VisitMut>::visit_mut_ts_type(&mut **self, node)
+    fn visit_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
-        <V as VisitMut>::visit_mut_ts_type_alias_decl(&mut **self, node)
+    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAliasDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_alias_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
-        <V as VisitMut>::visit_mut_ts_type_ann(&mut **self, node)
+    fn visit_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAnn,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
-        <V as VisitMut>::visit_mut_ts_type_assertion(&mut **self, node)
+    fn visit_ts_type_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
-        <V as VisitMut>::visit_mut_ts_type_element(&mut **self, node)
+    fn visit_ts_type_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
-        <V as VisitMut>::visit_mut_ts_type_elements(&mut **self, node)
+    fn visit_ts_type_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
-        <V as VisitMut>::visit_mut_ts_type_lit(&mut **self, node)
+    fn visit_ts_type_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
-        <V as VisitMut>::visit_mut_ts_type_operator(&mut **self, node)
+    fn visit_ts_type_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
-        <V as VisitMut>::visit_mut_ts_type_operator_op(&mut **self, node)
+    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperatorOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_operator_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
-        <V as VisitMut>::visit_mut_ts_type_param(&mut **self, node)
+    fn visit_ts_type_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
-        <V as VisitMut>::visit_mut_ts_type_param_decl(&mut **self, node)
+    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
-        <V as VisitMut>::visit_mut_ts_type_param_instantiation(&mut **self, node)
+    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
-        <V as VisitMut>::visit_mut_ts_type_params(&mut **self, node)
+    fn visit_ts_type_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
-        <V as VisitMut>::visit_mut_ts_type_predicate(&mut **self, node)
+    fn visit_ts_type_predicate<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypePredicate,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_predicate(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
-        <V as VisitMut>::visit_mut_ts_type_query(&mut **self, node)
+    fn visit_ts_type_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
-        <V as VisitMut>::visit_mut_ts_type_query_expr(&mut **self, node)
+    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQueryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_query_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
-        <V as VisitMut>::visit_mut_ts_type_ref(&mut **self, node)
+    fn visit_ts_type_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
-        <V as VisitMut>::visit_mut_ts_types(&mut **self, node)
+    fn visit_ts_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<TsType>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
-        <V as VisitMut>::visit_mut_ts_union_or_intersection_type(&mut **self, node)
+    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionOrIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_union_or_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
-        <V as VisitMut>::visit_mut_ts_union_type(&mut **self, node)
+    fn visit_ts_union_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_union_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
-        <V as VisitMut>::visit_mut_unary_expr(&mut **self, node)
+    fn visit_unary_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unary_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
-        <V as VisitMut>::visit_mut_unary_op(&mut **self, node)
+    fn visit_unary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
-        <V as VisitMut>::visit_mut_update_expr(&mut **self, node)
+    fn visit_update_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_update_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
-        <V as VisitMut>::visit_mut_update_op(&mut **self, node)
+    fn visit_update_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_update_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
-        <V as VisitMut>::visit_mut_using_decl(&mut **self, node)
+    fn visit_using_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UsingDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_using_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
-        <V as VisitMut>::visit_mut_var_decl(&mut **self, node)
+    fn visit_var_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
-        <V as VisitMut>::visit_mut_var_decl_kind(&mut **self, node)
+    fn visit_var_decl_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
-        <V as VisitMut>::visit_mut_var_decl_or_expr(&mut **self, node)
+    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
-        <V as VisitMut>::visit_mut_var_declarator(&mut **self, node)
+    fn visit_var_declarator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclarator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_declarator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
-        <V as VisitMut>::visit_mut_var_declarators(&mut **self, node)
+    fn visit_var_declarators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [VarDeclarator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_declarators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
-        <V as VisitMut>::visit_mut_while_stmt(&mut **self, node)
+    fn visit_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
-        <V as VisitMut>::visit_mut_with_stmt(&mut **self, node)
+    fn visit_with_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WithStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_with_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
-        <V as VisitMut>::visit_mut_yield_expr(&mut **self, node)
+    fn visit_yield_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast YieldExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_yield_expr(&mut **self, node, __ast_path)
     }
 }
-impl<V> VisitMut for Box<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitAstPath for Box<V>
 where
-    V: ?Sized + VisitMut,
+    V: ?Sized + VisitAstPath,
 {
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
-        <V as VisitMut>::visit_mut_accessibility(&mut **self, node)
+    fn visit_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Accessibility,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
-        <V as VisitMut>::visit_mut_array_lit(&mut **self, node)
+    fn visit_array_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_array_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
-        <V as VisitMut>::visit_mut_array_pat(&mut **self, node)
+    fn visit_array_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_array_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
-        <V as VisitMut>::visit_mut_arrow_expr(&mut **self, node)
+    fn visit_arrow_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrowExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_arrow_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
-        <V as VisitMut>::visit_mut_assign_expr(&mut **self, node)
+    fn visit_assign_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
-        <V as VisitMut>::visit_mut_assign_op(&mut **self, node)
+    fn visit_assign_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
-        <V as VisitMut>::visit_mut_assign_pat(&mut **self, node)
+    fn visit_assign_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
-        <V as VisitMut>::visit_mut_assign_pat_prop(&mut **self, node)
+    fn visit_assign_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
-        <V as VisitMut>::visit_mut_assign_prop(&mut **self, node)
+    fn visit_assign_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
-        <V as VisitMut>::visit_mut_assign_target(&mut **self, node)
+    fn visit_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
-        <V as VisitMut>::visit_mut_assign_target_pat(&mut **self, node)
+    fn visit_assign_target_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTargetPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_target_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
-        <V as VisitMut>::visit_mut_atom(&mut **self, node)
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
-        <V as VisitMut>::visit_mut_auto_accessor(&mut **self, node)
+    fn visit_auto_accessor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AutoAccessor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_auto_accessor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
-        <V as VisitMut>::visit_mut_await_expr(&mut **self, node)
+    fn visit_await_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AwaitExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_await_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
-        <V as VisitMut>::visit_mut_big_int(&mut **self, node)
+    fn visit_big_int<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigInt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_big_int(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
-        <V as VisitMut>::visit_mut_big_int_value(&mut **self, node)
+    fn visit_big_int_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigIntValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_big_int_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
-        <V as VisitMut>::visit_mut_bin_expr(&mut **self, node)
+    fn visit_bin_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_bin_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
-        <V as VisitMut>::visit_mut_binary_op(&mut **self, node)
+    fn visit_binary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_binary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
-        <V as VisitMut>::visit_mut_binding_ident(&mut **self, node)
+    fn visit_binding_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BindingIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_binding_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
-        <V as VisitMut>::visit_mut_block_stmt(&mut **self, node)
+    fn visit_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
-        <V as VisitMut>::visit_mut_block_stmt_or_expr(&mut **self, node)
+    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmtOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_block_stmt_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool) {
-        <V as VisitMut>::visit_mut_bool(&mut **self, node)
+    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_bool(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
-        <V as VisitMut>::visit_mut_break_stmt(&mut **self, node)
+    fn visit_break_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BreakStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_break_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
-        <V as VisitMut>::visit_mut_call_expr(&mut **self, node)
+    fn visit_call_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CallExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_call_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee) {
-        <V as VisitMut>::visit_mut_callee(&mut **self, node)
+    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_callee(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
-        <V as VisitMut>::visit_mut_catch_clause(&mut **self, node)
+    fn visit_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CatchClause,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class) {
-        <V as VisitMut>::visit_mut_class(&mut **self, node)
+    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_class(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
-        <V as VisitMut>::visit_mut_class_decl(&mut **self, node)
+    fn visit_class_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
-        <V as VisitMut>::visit_mut_class_expr(&mut **self, node)
+    fn visit_class_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
-        <V as VisitMut>::visit_mut_class_member(&mut **self, node)
+    fn visit_class_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
-        <V as VisitMut>::visit_mut_class_members(&mut **self, node)
+    fn visit_class_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ClassMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
-        <V as VisitMut>::visit_mut_class_method(&mut **self, node)
+    fn visit_class_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
-        <V as VisitMut>::visit_mut_class_prop(&mut **self, node)
+    fn visit_class_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
-        <V as VisitMut>::visit_mut_computed_prop_name(&mut **self, node)
+    fn visit_computed_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComputedPropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_computed_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
-        <V as VisitMut>::visit_mut_cond_expr(&mut **self, node)
+    fn visit_cond_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CondExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_cond_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
-        <V as VisitMut>::visit_mut_constructor(&mut **self, node)
+    fn visit_constructor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Constructor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_constructor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
-        <V as VisitMut>::visit_mut_continue_stmt(&mut **self, node)
+    fn visit_continue_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContinueStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_continue_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
-        <V as VisitMut>::visit_mut_debugger_stmt(&mut **self, node)
+    fn visit_debugger_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DebuggerStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_debugger_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl) {
-        <V as VisitMut>::visit_mut_decl(&mut **self, node)
+    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
-        <V as VisitMut>::visit_mut_decorator(&mut **self, node)
+    fn visit_decorator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Decorator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_decorator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
-        <V as VisitMut>::visit_mut_decorators(&mut **self, node)
+    fn visit_decorators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Decorator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_decorators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
-        <V as VisitMut>::visit_mut_default_decl(&mut **self, node)
+    fn visit_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
-        <V as VisitMut>::visit_mut_do_while_stmt(&mut **self, node)
+    fn visit_do_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DoWhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_do_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
-        <V as VisitMut>::visit_mut_empty_stmt(&mut **self, node)
+    fn visit_empty_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EmptyStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_empty_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
-        <V as VisitMut>::visit_mut_es_version(&mut **self, node)
+    fn visit_es_version<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EsVersion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_es_version(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
-        <V as VisitMut>::visit_mut_export_all(&mut **self, node)
+    fn visit_export_all<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportAll,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_all(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
-        <V as VisitMut>::visit_mut_export_decl(&mut **self, node)
+    fn visit_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
-        <V as VisitMut>::visit_mut_export_default_decl(&mut **self, node)
+    fn visit_export_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
-        <V as VisitMut>::visit_mut_export_default_expr(&mut **self, node)
+    fn visit_export_default_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
-        <V as VisitMut>::visit_mut_export_default_specifier(&mut **self, node)
+    fn visit_export_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
-        <V as VisitMut>::visit_mut_export_named_specifier(&mut **self, node)
+    fn visit_export_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
-        <V as VisitMut>::visit_mut_export_namespace_specifier(&mut **self, node)
+    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamespaceSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_namespace_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
-        <V as VisitMut>::visit_mut_export_specifier(&mut **self, node)
+    fn visit_export_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
-        <V as VisitMut>::visit_mut_export_specifiers(&mut **self, node)
+    fn visit_export_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr) {
-        <V as VisitMut>::visit_mut_expr(&mut **self, node)
+    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
-        <V as VisitMut>::visit_mut_expr_or_spread(&mut **self, node)
+    fn visit_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
-        <V as VisitMut>::visit_mut_expr_or_spreads(&mut **self, node)
+    fn visit_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExprOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
-        <V as VisitMut>::visit_mut_expr_stmt(&mut **self, node)
+    fn visit_expr_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
-        <V as VisitMut>::visit_mut_exprs(&mut **self, node)
+    fn visit_exprs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<Expr>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_exprs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
-        <V as VisitMut>::visit_mut_fn_decl(&mut **self, node)
+    fn visit_fn_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_fn_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
-        <V as VisitMut>::visit_mut_fn_expr(&mut **self, node)
+    fn visit_fn_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_fn_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
-        <V as VisitMut>::visit_mut_for_head(&mut **self, node)
+    fn visit_for_head<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForHead,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_head(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
-        <V as VisitMut>::visit_mut_for_in_stmt(&mut **self, node)
+    fn visit_for_in_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForInStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_in_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
-        <V as VisitMut>::visit_mut_for_of_stmt(&mut **self, node)
+    fn visit_for_of_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForOfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_of_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
-        <V as VisitMut>::visit_mut_for_stmt(&mut **self, node)
+    fn visit_for_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
-        <V as VisitMut>::visit_mut_function(&mut **self, node)
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
-        <V as VisitMut>::visit_mut_getter_prop(&mut **self, node)
+    fn visit_getter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast GetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_getter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
-        <V as VisitMut>::visit_mut_ident(&mut **self, node)
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
-        <V as VisitMut>::visit_mut_ident_name(&mut **self, node)
+    fn visit_ident_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdentName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ident_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
-        <V as VisitMut>::visit_mut_if_stmt(&mut **self, node)
+    fn visit_if_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_if_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import) {
-        <V as VisitMut>::visit_mut_import(&mut **self, node)
+    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_import(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
-        <V as VisitMut>::visit_mut_import_decl(&mut **self, node)
+    fn visit_import_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
-        <V as VisitMut>::visit_mut_import_default_specifier(&mut **self, node)
+    fn visit_import_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
-        <V as VisitMut>::visit_mut_import_named_specifier(&mut **self, node)
+    fn visit_import_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
-        <V as VisitMut>::visit_mut_import_phase(&mut **self, node)
+    fn visit_import_phase<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPhase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_phase(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
-        <V as VisitMut>::visit_mut_import_specifier(&mut **self, node)
+    fn visit_import_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
-        <V as VisitMut>::visit_mut_import_specifiers(&mut **self, node)
+    fn visit_import_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
-        <V as VisitMut>::visit_mut_import_star_as_specifier(&mut **self, node)
+    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportStarAsSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_star_as_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
-        <V as VisitMut>::visit_mut_import_with(&mut **self, node)
+    fn visit_import_with<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWith,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
-        <V as VisitMut>::visit_mut_import_with_item(&mut **self, node)
+    fn visit_import_with_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWithItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
-        <V as VisitMut>::visit_mut_import_with_items(&mut **self, node)
+    fn visit_import_with_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportWithItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
-        <V as VisitMut>::visit_mut_invalid(&mut **self, node)
+    fn visit_invalid<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Invalid,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_invalid(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
-        <V as VisitMut>::visit_mut_jsx_attr(&mut **self, node)
+    fn visit_jsx_attr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
-        <V as VisitMut>::visit_mut_jsx_attr_name(&mut **self, node)
+    fn visit_jsx_attr_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
-        <V as VisitMut>::visit_mut_jsx_attr_or_spread(&mut **self, node)
+    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
-        <V as VisitMut>::visit_mut_jsx_attr_or_spreads(&mut **self, node)
+    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXAttrOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
-        <V as VisitMut>::visit_mut_jsx_attr_value(&mut **self, node)
+    fn visit_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
-        <V as VisitMut>::visit_mut_jsx_closing_element(&mut **self, node)
+    fn visit_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
-        <V as VisitMut>::visit_mut_jsx_closing_fragment(&mut **self, node)
+    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_closing_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
-        <V as VisitMut>::visit_mut_jsx_element(&mut **self, node)
+    fn visit_jsx_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
-        <V as VisitMut>::visit_mut_jsx_element_child(&mut **self, node)
+    fn visit_jsx_element_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
-        <V as VisitMut>::visit_mut_jsx_element_childs(&mut **self, node)
+    fn visit_jsx_element_childs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXElementChild],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_childs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
-        <V as VisitMut>::visit_mut_jsx_element_name(&mut **self, node)
+    fn visit_jsx_element_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
-        <V as VisitMut>::visit_mut_jsx_empty_expr(&mut **self, node)
+    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXEmptyExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_empty_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
-        <V as VisitMut>::visit_mut_jsx_expr(&mut **self, node)
+    fn visit_jsx_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
-        <V as VisitMut>::visit_mut_jsx_expr_container(&mut **self, node)
+    fn visit_jsx_expr_container<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExprContainer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_expr_container(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
-        <V as VisitMut>::visit_mut_jsx_fragment(&mut **self, node)
+    fn visit_jsx_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
-        <V as VisitMut>::visit_mut_jsx_member_expr(&mut **self, node)
+    fn visit_jsx_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXMemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
-        <V as VisitMut>::visit_mut_jsx_namespaced_name(&mut **self, node)
+    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXNamespacedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_namespaced_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
-        <V as VisitMut>::visit_mut_jsx_object(&mut **self, node)
+    fn visit_jsx_object<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXObject,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_object(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
-        <V as VisitMut>::visit_mut_jsx_opening_element(&mut **self, node)
+    fn visit_jsx_opening_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_opening_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
-        <V as VisitMut>::visit_mut_jsx_opening_fragment(&mut **self, node)
+    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_opening_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
-        <V as VisitMut>::visit_mut_jsx_spread_child(&mut **self, node)
+    fn visit_jsx_spread_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXSpreadChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_spread_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
-        <V as VisitMut>::visit_mut_jsx_text(&mut **self, node)
+    fn visit_jsx_text<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXText,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_text(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key) {
-        <V as VisitMut>::visit_mut_key(&mut **self, node)
+    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_key(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
-        <V as VisitMut>::visit_mut_key_value_pat_prop(&mut **self, node)
+    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValuePatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_key_value_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
-        <V as VisitMut>::visit_mut_key_value_prop(&mut **self, node)
+    fn visit_key_value_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValueProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_key_value_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
-        <V as VisitMut>::visit_mut_labeled_stmt(&mut **self, node)
+    fn visit_labeled_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LabeledStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_labeled_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit) {
-        <V as VisitMut>::visit_mut_lit(&mut **self, node)
+    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
-        <V as VisitMut>::visit_mut_member_expr(&mut **self, node)
+    fn visit_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
-        <V as VisitMut>::visit_mut_member_prop(&mut **self, node)
+    fn visit_member_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_member_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
-        <V as VisitMut>::visit_mut_meta_prop_expr(&mut **self, node)
+    fn visit_meta_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_meta_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
-        <V as VisitMut>::visit_mut_meta_prop_kind(&mut **self, node)
+    fn visit_meta_prop_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_meta_prop_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
-        <V as VisitMut>::visit_mut_method_kind(&mut **self, node)
+    fn visit_method_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_method_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
-        <V as VisitMut>::visit_mut_method_prop(&mut **self, node)
+    fn visit_method_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_method_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module) {
-        <V as VisitMut>::visit_mut_module(&mut **self, node)
+    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_module(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
-        <V as VisitMut>::visit_mut_module_decl(&mut **self, node)
+    fn visit_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
-        <V as VisitMut>::visit_mut_module_export_name(&mut **self, node)
+    fn visit_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleExportName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
-        <V as VisitMut>::visit_mut_module_item(&mut **self, node)
+    fn visit_module_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
-        <V as VisitMut>::visit_mut_module_items(&mut **self, node)
+    fn visit_module_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ModuleItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
-        <V as VisitMut>::visit_mut_named_export(&mut **self, node)
+    fn visit_named_export<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedExport,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_named_export(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
-        <V as VisitMut>::visit_mut_new_expr(&mut **self, node)
+    fn visit_new_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NewExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_new_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null) {
-        <V as VisitMut>::visit_mut_null(&mut **self, node)
+    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_null(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
-        <V as VisitMut>::visit_mut_number(&mut **self, node)
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
-        <V as VisitMut>::visit_mut_object_lit(&mut **self, node)
+    fn visit_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
-        <V as VisitMut>::visit_mut_object_pat(&mut **self, node)
+    fn visit_object_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
-        <V as VisitMut>::visit_mut_object_pat_prop(&mut **self, node)
+    fn visit_object_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
-        <V as VisitMut>::visit_mut_object_pat_props(&mut **self, node)
+    fn visit_object_pat_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ObjectPatProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
-        <V as VisitMut>::visit_mut_opt_accessibility(&mut **self, node)
+    fn visit_opt_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Accessibility>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
-        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
-        <V as VisitMut>::visit_mut_opt_block_stmt(&mut **self, node)
+    fn visit_opt_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<BlockStmt>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
-        <V as VisitMut>::visit_mut_opt_call(&mut **self, node)
+    fn visit_opt_call<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptCall,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_call(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
-        <V as VisitMut>::visit_mut_opt_catch_clause(&mut **self, node)
+    fn visit_opt_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<CatchClause>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
-        <V as VisitMut>::visit_mut_opt_chain_base(&mut **self, node)
+    fn visit_opt_chain_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_chain_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
-        <V as VisitMut>::visit_mut_opt_chain_expr(&mut **self, node)
+    fn visit_opt_chain_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_chain_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
-        <V as VisitMut>::visit_mut_opt_expr(&mut **self, node)
+    fn visit_opt_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Expr>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
-        <V as VisitMut>::visit_mut_opt_expr_or_spread(&mut **self, node)
+    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ExprOrSpread>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
-        <V as VisitMut>::visit_mut_opt_expr_or_spreads(&mut **self, node)
+    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
-        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
-        <V as VisitMut>::visit_mut_opt_jsx_attr_value(&mut **self, node)
+    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXAttrValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
-        <V as VisitMut>::visit_mut_opt_jsx_closing_element(&mut **self, node)
+    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXClosingElement>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
-        <V as VisitMut>::visit_mut_opt_module_export_name(&mut **self, node)
+    fn visit_opt_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ModuleExportName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
-        <V as VisitMut>::visit_mut_opt_object_lit(&mut **self, node)
+    fn visit_opt_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ObjectLit>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
-        <V as VisitMut>::visit_mut_opt_pat(&mut **self, node)
+    fn visit_opt_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Pat>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
-        <V as VisitMut>::visit_mut_opt_span(&mut **self, node)
+    fn visit_opt_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_common::Span>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
-        <V as VisitMut>::visit_mut_opt_stmt(&mut **self, node)
+    fn visit_opt_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Stmt>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
-        <V as VisitMut>::visit_mut_opt_str(&mut **self, node)
+    fn visit_opt_str<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Str>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
-        <V as VisitMut>::visit_mut_opt_true_plus_minus(&mut **self, node)
+    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TruePlusMinus>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
-        <V as VisitMut>::visit_mut_opt_ts_entity_name(&mut **self, node)
+    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsEntityName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
-        <V as VisitMut>::visit_mut_opt_ts_namespace_body(&mut **self, node)
+    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsNamespaceBody>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
-        <V as VisitMut>::visit_mut_opt_ts_type(&mut **self, node)
+    fn visit_opt_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
-        <V as VisitMut>::visit_mut_opt_ts_type_ann(&mut **self, node)
+    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
-        <V as VisitMut>::visit_mut_opt_ts_type_param_decl(&mut **self, node)
+    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_instantiation(
+    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        node: &'ast Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
-        <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(&mut **self, node)
+        <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
-        <V as VisitMut>::visit_mut_opt_var_decl_or_expr(&mut **self, node)
+    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<VarDeclOrExpr>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
-        <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node)
+    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<ExprOrSpread>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
-        <V as VisitMut>::visit_mut_opt_vec_pats(&mut **self, node)
+    fn visit_opt_vec_pats<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<Pat>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_vec_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param) {
-        <V as VisitMut>::visit_mut_param(&mut **self, node)
+    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
-        <V as VisitMut>::visit_mut_param_or_ts_param_prop(&mut **self, node)
+    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParamOrTsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_param_or_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
-        <V as VisitMut>::visit_mut_param_or_ts_param_props(&mut **self, node)
+    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ParamOrTsParamProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_param_or_ts_param_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
-        <V as VisitMut>::visit_mut_params(&mut **self, node)
+    fn visit_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Param],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
-        <V as VisitMut>::visit_mut_paren_expr(&mut **self, node)
+    fn visit_paren_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParenExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_paren_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat) {
-        <V as VisitMut>::visit_mut_pat(&mut **self, node)
+    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
-        <V as VisitMut>::visit_mut_pats(&mut **self, node)
+    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
-        <V as VisitMut>::visit_mut_private_method(&mut **self, node)
+    fn visit_private_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
-        <V as VisitMut>::visit_mut_private_name(&mut **self, node)
+    fn visit_private_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
-        <V as VisitMut>::visit_mut_private_prop(&mut **self, node)
+    fn visit_private_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program) {
-        <V as VisitMut>::visit_mut_program(&mut **self, node)
+    fn visit_program<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Program,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_program(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop) {
-        <V as VisitMut>::visit_mut_prop(&mut **self, node)
+    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
-        <V as VisitMut>::visit_mut_prop_name(&mut **self, node)
+    fn visit_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
-        <V as VisitMut>::visit_mut_prop_or_spread(&mut **self, node)
+    fn visit_prop_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
-        <V as VisitMut>::visit_mut_prop_or_spreads(&mut **self, node)
+    fn visit_prop_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PropOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex) {
-        <V as VisitMut>::visit_mut_regex(&mut **self, node)
+    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_regex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
-        <V as VisitMut>::visit_mut_rest_pat(&mut **self, node)
+    fn visit_rest_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RestPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_rest_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
-        <V as VisitMut>::visit_mut_return_stmt(&mut **self, node)
+    fn visit_return_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ReturnStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_return_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script) {
-        <V as VisitMut>::visit_mut_script(&mut **self, node)
+    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_script(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
-        <V as VisitMut>::visit_mut_seq_expr(&mut **self, node)
+    fn visit_seq_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SeqExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_seq_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
-        <V as VisitMut>::visit_mut_setter_prop(&mut **self, node)
+    fn visit_setter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_setter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
-        <V as VisitMut>::visit_mut_simple_assign_target(&mut **self, node)
+    fn visit_simple_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleAssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_simple_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
-        <V as VisitMut>::visit_mut_span(&mut **self, node)
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
-        <V as VisitMut>::visit_mut_spread_element(&mut **self, node)
+    fn visit_spread_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SpreadElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_spread_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
-        <V as VisitMut>::visit_mut_static_block(&mut **self, node)
+    fn visit_static_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StaticBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_static_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
-        <V as VisitMut>::visit_mut_stmt(&mut **self, node)
+    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
-        <V as VisitMut>::visit_mut_stmts(&mut **self, node)
+    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_stmts(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
-        <V as VisitMut>::visit_mut_str(&mut **self, node)
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super) {
-        <V as VisitMut>::visit_mut_super(&mut **self, node)
+    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_super(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
-        <V as VisitMut>::visit_mut_super_prop(&mut **self, node)
+    fn visit_super_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_super_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
-        <V as VisitMut>::visit_mut_super_prop_expr(&mut **self, node)
+    fn visit_super_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_super_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
-        <V as VisitMut>::visit_mut_switch_case(&mut **self, node)
+    fn visit_switch_case<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchCase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_case(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
-        <V as VisitMut>::visit_mut_switch_cases(&mut **self, node)
+    fn visit_switch_cases<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SwitchCase],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_cases(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
-        <V as VisitMut>::visit_mut_switch_stmt(&mut **self, node)
+    fn visit_switch_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
-        <V as VisitMut>::visit_mut_syntax_context(&mut **self, node)
+    fn visit_syntax_context<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::SyntaxContext,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_syntax_context(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
-        <V as VisitMut>::visit_mut_tagged_tpl(&mut **self, node)
+    fn visit_tagged_tpl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TaggedTpl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tagged_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
-        <V as VisitMut>::visit_mut_this_expr(&mut **self, node)
+    fn visit_this_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThisExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_this_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
-        <V as VisitMut>::visit_mut_throw_stmt(&mut **self, node)
+    fn visit_throw_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThrowStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_throw_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
-        <V as VisitMut>::visit_mut_tpl(&mut **self, node)
+    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
-        <V as VisitMut>::visit_mut_tpl_element(&mut **self, node)
+    fn visit_tpl_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TplElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tpl_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
-        <V as VisitMut>::visit_mut_tpl_elements(&mut **self, node)
+    fn visit_tpl_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TplElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tpl_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
-        <V as VisitMut>::visit_mut_true_plus_minus(&mut **self, node)
+    fn visit_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TruePlusMinus,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
-        <V as VisitMut>::visit_mut_try_stmt(&mut **self, node)
+    fn visit_try_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TryStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_try_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
-        <V as VisitMut>::visit_mut_ts_array_type(&mut **self, node)
+    fn visit_ts_array_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsArrayType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_array_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
-        <V as VisitMut>::visit_mut_ts_as_expr(&mut **self, node)
+    fn visit_ts_as_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsAsExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_as_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
-        <V as VisitMut>::visit_mut_ts_call_signature_decl(&mut **self, node)
+    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsCallSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_call_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
-        <V as VisitMut>::visit_mut_ts_conditional_type(&mut **self, node)
+    fn visit_ts_conditional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConditionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_conditional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
-        <V as VisitMut>::visit_mut_ts_const_assertion(&mut **self, node)
+    fn visit_ts_const_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_const_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
-        <V as VisitMut>::visit_mut_ts_construct_signature_decl(&mut **self, node)
+    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_construct_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
-        <V as VisitMut>::visit_mut_ts_constructor_type(&mut **self, node)
+    fn visit_ts_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
-        <V as VisitMut>::visit_mut_ts_entity_name(&mut **self, node)
+    fn visit_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEntityName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
-        <V as VisitMut>::visit_mut_ts_enum_decl(&mut **self, node)
+    fn visit_ts_enum_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
-        <V as VisitMut>::visit_mut_ts_enum_member(&mut **self, node)
+    fn visit_ts_enum_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
-        <V as VisitMut>::visit_mut_ts_enum_member_id(&mut **self, node)
+    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMemberId,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_member_id(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
-        <V as VisitMut>::visit_mut_ts_enum_members(&mut **self, node)
+    fn visit_ts_enum_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsEnumMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
-        <V as VisitMut>::visit_mut_ts_export_assignment(&mut **self, node)
+    fn visit_ts_export_assignment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExportAssignment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_export_assignment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
-        <V as VisitMut>::visit_mut_ts_expr_with_type_args(&mut **self, node)
+    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExprWithTypeArgs,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_expr_with_type_args(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
-        <V as VisitMut>::visit_mut_ts_expr_with_type_argss(&mut **self, node)
+    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsExprWithTypeArgs],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_expr_with_type_argss(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
-        <V as VisitMut>::visit_mut_ts_external_module_ref(&mut **self, node)
+    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExternalModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_external_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
-        <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(&mut **self, node)
+    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnOrConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
-        <V as VisitMut>::visit_mut_ts_fn_param(&mut **self, node)
+    fn visit_ts_fn_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
-        <V as VisitMut>::visit_mut_ts_fn_params(&mut **self, node)
+    fn visit_ts_fn_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsFnParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
-        <V as VisitMut>::visit_mut_ts_fn_type(&mut **self, node)
+    fn visit_ts_fn_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
-        <V as VisitMut>::visit_mut_ts_getter_signature(&mut **self, node)
+    fn visit_ts_getter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsGetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_getter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
-        <V as VisitMut>::visit_mut_ts_import_equals_decl(&mut **self, node)
+    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportEqualsDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_import_equals_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
-        <V as VisitMut>::visit_mut_ts_import_type(&mut **self, node)
+    fn visit_ts_import_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_import_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
-        <V as VisitMut>::visit_mut_ts_index_signature(&mut **self, node)
+    fn visit_ts_index_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_index_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
-        <V as VisitMut>::visit_mut_ts_indexed_access_type(&mut **self, node)
+    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexedAccessType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_indexed_access_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
-        <V as VisitMut>::visit_mut_ts_infer_type(&mut **self, node)
+    fn visit_ts_infer_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInferType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_infer_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
-        <V as VisitMut>::visit_mut_ts_instantiation(&mut **self, node)
+    fn visit_ts_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
-        <V as VisitMut>::visit_mut_ts_interface_body(&mut **self, node)
+    fn visit_ts_interface_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_interface_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
-        <V as VisitMut>::visit_mut_ts_interface_decl(&mut **self, node)
+    fn visit_ts_interface_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_interface_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
-        <V as VisitMut>::visit_mut_ts_intersection_type(&mut **self, node)
+    fn visit_ts_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
-        <V as VisitMut>::visit_mut_ts_keyword_type(&mut **self, node)
+    fn visit_ts_keyword_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_keyword_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
-        <V as VisitMut>::visit_mut_ts_keyword_type_kind(&mut **self, node)
+    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordTypeKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_keyword_type_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
-        <V as VisitMut>::visit_mut_ts_lit(&mut **self, node)
+    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
+        <V as VisitAstPath>::visit_ts_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
-        <V as VisitMut>::visit_mut_ts_lit_type(&mut **self, node)
+    fn visit_ts_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
-        <V as VisitMut>::visit_mut_ts_mapped_type(&mut **self, node)
+    fn visit_ts_mapped_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMappedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_mapped_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
-        <V as VisitMut>::visit_mut_ts_method_signature(&mut **self, node)
+    fn visit_ts_method_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMethodSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_method_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
-        <V as VisitMut>::visit_mut_ts_module_block(&mut **self, node)
+    fn visit_ts_module_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
-        <V as VisitMut>::visit_mut_ts_module_decl(&mut **self, node)
+    fn visit_ts_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
-        <V as VisitMut>::visit_mut_ts_module_name(&mut **self, node)
+    fn visit_ts_module_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
-        <V as VisitMut>::visit_mut_ts_module_ref(&mut **self, node)
+    fn visit_ts_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
-        <V as VisitMut>::visit_mut_ts_namespace_body(&mut **self, node)
+    fn visit_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
-        <V as VisitMut>::visit_mut_ts_namespace_decl(&mut **self, node)
+    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
-        <V as VisitMut>::visit_mut_ts_namespace_export_decl(&mut **self, node)
+    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
-        <V as VisitMut>::visit_mut_ts_non_null_expr(&mut **self, node)
+    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNonNullExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_non_null_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
-        <V as VisitMut>::visit_mut_ts_optional_type(&mut **self, node)
+    fn visit_ts_optional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsOptionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_optional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
-        <V as VisitMut>::visit_mut_ts_param_prop(&mut **self, node)
+    fn visit_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
-        <V as VisitMut>::visit_mut_ts_param_prop_param(&mut **self, node)
+    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamPropParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_param_prop_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
-        <V as VisitMut>::visit_mut_ts_parenthesized_type(&mut **self, node)
+    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParenthesizedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_parenthesized_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
-        <V as VisitMut>::visit_mut_ts_property_signature(&mut **self, node)
+    fn visit_ts_property_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsPropertySignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_property_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
-        <V as VisitMut>::visit_mut_ts_qualified_name(&mut **self, node)
+    fn visit_ts_qualified_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsQualifiedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_qualified_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
-        <V as VisitMut>::visit_mut_ts_rest_type(&mut **self, node)
+    fn visit_ts_rest_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsRestType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_rest_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
-        <V as VisitMut>::visit_mut_ts_satisfies_expr(&mut **self, node)
+    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSatisfiesExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_satisfies_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
-        <V as VisitMut>::visit_mut_ts_setter_signature(&mut **self, node)
+    fn visit_ts_setter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_setter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
-        <V as VisitMut>::visit_mut_ts_this_type(&mut **self, node)
+    fn visit_ts_this_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_this_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
-        <V as VisitMut>::visit_mut_ts_this_type_or_ident(&mut **self, node)
+    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisTypeOrIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_this_type_or_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
-        <V as VisitMut>::visit_mut_ts_tpl_lit_type(&mut **self, node)
+    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTplLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tpl_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
-        <V as VisitMut>::visit_mut_ts_tuple_element(&mut **self, node)
+    fn visit_ts_tuple_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
-        <V as VisitMut>::visit_mut_ts_tuple_elements(&mut **self, node)
+    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTupleElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
-        <V as VisitMut>::visit_mut_ts_tuple_type(&mut **self, node)
+    fn visit_ts_tuple_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
-        <V as VisitMut>::visit_mut_ts_type(&mut **self, node)
+    fn visit_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
-        <V as VisitMut>::visit_mut_ts_type_alias_decl(&mut **self, node)
+    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAliasDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_alias_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
-        <V as VisitMut>::visit_mut_ts_type_ann(&mut **self, node)
+    fn visit_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAnn,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
-        <V as VisitMut>::visit_mut_ts_type_assertion(&mut **self, node)
+    fn visit_ts_type_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
-        <V as VisitMut>::visit_mut_ts_type_element(&mut **self, node)
+    fn visit_ts_type_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
-        <V as VisitMut>::visit_mut_ts_type_elements(&mut **self, node)
+    fn visit_ts_type_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
-        <V as VisitMut>::visit_mut_ts_type_lit(&mut **self, node)
+    fn visit_ts_type_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
-        <V as VisitMut>::visit_mut_ts_type_operator(&mut **self, node)
+    fn visit_ts_type_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
-        <V as VisitMut>::visit_mut_ts_type_operator_op(&mut **self, node)
+    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperatorOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_operator_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
-        <V as VisitMut>::visit_mut_ts_type_param(&mut **self, node)
+    fn visit_ts_type_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
-        <V as VisitMut>::visit_mut_ts_type_param_decl(&mut **self, node)
+    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
-        <V as VisitMut>::visit_mut_ts_type_param_instantiation(&mut **self, node)
+    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
-        <V as VisitMut>::visit_mut_ts_type_params(&mut **self, node)
+    fn visit_ts_type_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
-        <V as VisitMut>::visit_mut_ts_type_predicate(&mut **self, node)
+    fn visit_ts_type_predicate<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypePredicate,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_predicate(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
-        <V as VisitMut>::visit_mut_ts_type_query(&mut **self, node)
+    fn visit_ts_type_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
-        <V as VisitMut>::visit_mut_ts_type_query_expr(&mut **self, node)
+    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQueryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_query_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
-        <V as VisitMut>::visit_mut_ts_type_ref(&mut **self, node)
+    fn visit_ts_type_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
-        <V as VisitMut>::visit_mut_ts_types(&mut **self, node)
+    fn visit_ts_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<TsType>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
-        <V as VisitMut>::visit_mut_ts_union_or_intersection_type(&mut **self, node)
+    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionOrIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_union_or_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
-        <V as VisitMut>::visit_mut_ts_union_type(&mut **self, node)
+    fn visit_ts_union_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_union_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
-        <V as VisitMut>::visit_mut_unary_expr(&mut **self, node)
+    fn visit_unary_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unary_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
-        <V as VisitMut>::visit_mut_unary_op(&mut **self, node)
+    fn visit_unary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
-        <V as VisitMut>::visit_mut_update_expr(&mut **self, node)
+    fn visit_update_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_update_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
-        <V as VisitMut>::visit_mut_update_op(&mut **self, node)
+    fn visit_update_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_update_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
-        <V as VisitMut>::visit_mut_using_decl(&mut **self, node)
+    fn visit_using_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UsingDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_using_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
-        <V as VisitMut>::visit_mut_var_decl(&mut **self, node)
+    fn visit_var_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
-        <V as VisitMut>::visit_mut_var_decl_kind(&mut **self, node)
+    fn visit_var_decl_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
-        <V as VisitMut>::visit_mut_var_decl_or_expr(&mut **self, node)
+    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
-        <V as VisitMut>::visit_mut_var_declarator(&mut **self, node)
+    fn visit_var_declarator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclarator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_declarator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
-        <V as VisitMut>::visit_mut_var_declarators(&mut **self, node)
+    fn visit_var_declarators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [VarDeclarator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_declarators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
-        <V as VisitMut>::visit_mut_while_stmt(&mut **self, node)
+    fn visit_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
-        <V as VisitMut>::visit_mut_with_stmt(&mut **self, node)
+    fn visit_with_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WithStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_with_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
-        <V as VisitMut>::visit_mut_yield_expr(&mut **self, node)
+    fn visit_yield_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast YieldExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_yield_expr(&mut **self, node, __ast_path)
     }
 }
-impl<A, B> VisitMut for ::swc_visit::Either<A, B>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<A, B> VisitAstPath for ::swc_visit::Either<A, B>
 where
-    A: VisitMut,
-    B: VisitMut,
+    A: VisitAstPath,
+    B: VisitAstPath,
 {
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
+    fn visit_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Accessibility,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_accessibility(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_accessibility(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_accessibility(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_accessibility(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
+    fn visit_array_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_array_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_array_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_array_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_array_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
+    fn visit_array_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_array_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_array_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_array_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_array_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
+    fn visit_arrow_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrowExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_arrow_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_arrow_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_arrow_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_arrow_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
+    fn visit_assign_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_assign_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_assign_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
+    fn visit_assign_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_assign_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_assign_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
+    fn visit_assign_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_assign_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_assign_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
+    fn visit_assign_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_assign_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_assign_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
+    fn visit_assign_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_assign_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_assign_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
+    fn visit_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_target(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_target(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_assign_target(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_assign_target(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
+    fn visit_assign_target_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTargetPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_assign_target_pat(visitor, node)
+                VisitAstPath::visit_assign_target_pat(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_assign_target_pat(visitor, node)
+                VisitAstPath::visit_assign_target_pat(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_atom(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
+    fn visit_auto_accessor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AutoAccessor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_auto_accessor(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_auto_accessor(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_auto_accessor(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_auto_accessor(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
+    fn visit_await_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AwaitExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_await_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_await_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_await_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_await_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
+    fn visit_big_int<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigInt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_big_int(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_big_int(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_big_int(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_big_int(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
+    fn visit_big_int_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigIntValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_big_int_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_big_int_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_big_int_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_big_int_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
+    fn visit_bin_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_bin_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_bin_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_bin_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_bin_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
+    fn visit_binary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_binary_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_binary_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_binary_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_binary_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
+    fn visit_binding_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BindingIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_binding_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_binding_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_binding_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_binding_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
+    fn visit_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_block_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_block_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_block_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_block_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
+    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmtOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_block_stmt_or_expr(visitor, node)
+                VisitAstPath::visit_block_stmt_or_expr(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_block_stmt_or_expr(visitor, node)
+                VisitAstPath::visit_block_stmt_or_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool) {
+    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_bool(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_bool(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_bool(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_bool(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
+    fn visit_break_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BreakStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_break_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_break_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_break_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_break_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
+    fn visit_call_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CallExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_call_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_call_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_call_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_call_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee) {
+    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_callee(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_callee(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_callee(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_callee(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
+    fn visit_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CatchClause,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_catch_clause(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_catch_clause(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_catch_clause(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_catch_clause(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class) {
+    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
+    fn visit_class_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
+    fn visit_class_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
+    fn visit_class_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_member(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_member(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class_member(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class_member(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
+    fn visit_class_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ClassMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_members(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_members(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class_members(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class_members(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
+    fn visit_class_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_method(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_method(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class_method(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class_method(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
+    fn visit_class_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_class_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_class_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
+    fn visit_computed_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComputedPropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_computed_prop_name(visitor, node)
+                VisitAstPath::visit_computed_prop_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_computed_prop_name(visitor, node)
+                VisitAstPath::visit_computed_prop_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
+    fn visit_cond_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CondExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_cond_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_cond_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_cond_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_cond_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
+    fn visit_constructor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Constructor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_constructor(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_constructor(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_constructor(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_constructor(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
+    fn visit_continue_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContinueStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_continue_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_continue_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_continue_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_continue_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
+    fn visit_debugger_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DebuggerStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_debugger_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_debugger_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_debugger_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_debugger_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl) {
+    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_decl(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
+    fn visit_decorator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Decorator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_decorator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_decorator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_decorator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_decorator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
+    fn visit_decorators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Decorator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_decorators(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_decorators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_decorators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_decorators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
+    fn visit_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_default_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_default_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_default_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_default_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
+    fn visit_do_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DoWhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_do_while_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_do_while_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_do_while_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_do_while_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
+    fn visit_empty_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EmptyStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_empty_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_empty_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_empty_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_empty_stmt(visitor, node, __ast_path)
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_es_version<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EsVersion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_es_version(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_es_version(visitor, node, __ast_path)
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_export_all<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportAll,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        match self {
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_export_all(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_export_all(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
+    fn visit_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_es_version(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_es_version(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_export_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_export_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
+    fn visit_export_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_export_all(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_export_all(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_export_default_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_export_default_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
+    fn visit_export_default_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_export_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_export_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_export_default_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_export_default_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
+    fn visit_export_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_export_default_decl(visitor, node)
+                VisitAstPath::visit_export_default_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_export_default_decl(visitor, node)
+                VisitAstPath::visit_export_default_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
+    fn visit_export_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_export_default_expr(visitor, node)
+                VisitAstPath::visit_export_named_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_export_default_expr(visitor, node)
+                VisitAstPath::visit_export_named_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
+    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamespaceSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_export_default_specifier(visitor, node)
+                VisitAstPath::visit_export_namespace_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_export_default_specifier(visitor, node)
+                VisitAstPath::visit_export_namespace_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
+    fn visit_export_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_export_named_specifier(visitor, node)
+                VisitAstPath::visit_export_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_export_named_specifier(visitor, node)
+                VisitAstPath::visit_export_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
+    fn visit_export_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_export_namespace_specifier(visitor, node)
+                VisitAstPath::visit_export_specifiers(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_export_namespace_specifier(visitor, node)
+                VisitAstPath::visit_export_specifiers(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
+    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_export_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_expr(visitor, node, __ast_path),
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_export_specifier(visitor, node)
+                VisitAstPath::visit_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
+    fn visit_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_export_specifiers(visitor, node)
+                VisitAstPath::visit_expr_or_spread(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_export_specifiers(visitor, node)
+                VisitAstPath::visit_expr_or_spread(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
+    fn visit_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExprOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_expr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_expr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
+    fn visit_expr_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_expr_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_expr_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
+    fn visit_exprs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<Expr>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_exprs(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_exprs(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
+    fn visit_fn_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_exprs(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_exprs(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_fn_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_fn_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
+    fn visit_fn_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_fn_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_fn_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_fn_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_fn_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
+    fn visit_for_head<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForHead,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_fn_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_fn_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_for_head(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_for_head(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
+    fn visit_for_in_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForInStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_head(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_head(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_for_in_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_for_in_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
+    fn visit_for_of_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForOfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_in_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_in_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_for_of_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_for_of_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
+    fn visit_for_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_of_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_of_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_for_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_for_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
+    fn visit_getter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast GetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_function(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_getter_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_getter_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_getter_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_getter_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
+    fn visit_ident_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdentName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ident_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ident_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
+    fn visit_if_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ident_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ident_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_if_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_if_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
+    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_if_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_if_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_import(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_import(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import) {
+    fn visit_import_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_import_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_import_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
+    fn visit_import_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_import_default_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_import_default_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
+    fn visit_import_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_import_default_specifier(visitor, node)
+                VisitAstPath::visit_import_named_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_default_specifier(visitor, node)
+                VisitAstPath::visit_import_named_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
+    fn visit_import_phase<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPhase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_import_named_specifier(visitor, node)
+                VisitAstPath::visit_import_phase(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_named_specifier(visitor, node)
+                VisitAstPath::visit_import_phase(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
+    fn visit_import_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_phase(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_phase(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_import_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_import_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
+    fn visit_import_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_import_specifiers(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_specifier(visitor, node)
+                VisitAstPath::visit_import_specifiers(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
+    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportStarAsSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_import_specifiers(visitor, node)
+                VisitAstPath::visit_import_star_as_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_specifiers(visitor, node)
+                VisitAstPath::visit_import_star_as_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
+    fn visit_import_with<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWith,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_import_star_as_specifier(visitor, node)
+                VisitAstPath::visit_import_with(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_star_as_specifier(visitor, node)
+                VisitAstPath::visit_import_with(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
+    fn visit_import_with_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWithItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_with(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_with(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_import_with_item(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_import_with_item(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
+    fn visit_import_with_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportWithItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_with_item(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_import_with_items(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_with_item(visitor, node)
+                VisitAstPath::visit_import_with_items(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
+    fn visit_invalid<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Invalid,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_import_with_items(visitor, node)
+                VisitAstPath::visit_invalid(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_import_with_items(visitor, node)
+                VisitAstPath::visit_invalid(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
+    fn visit_jsx_attr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_invalid(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_invalid(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_attr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_attr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
+    fn visit_jsx_attr_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_attr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_attr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_attr_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_attr_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
+    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_attr_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_attr_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_attr_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_attr_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
+    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXAttrOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_attr_or_spread(visitor, node)
+                VisitAstPath::visit_jsx_attr_or_spreads(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_attr_or_spread(visitor, node)
+                VisitAstPath::visit_jsx_attr_or_spreads(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
+    fn visit_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_attr_or_spreads(visitor, node)
+                VisitAstPath::visit_jsx_attr_value(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_attr_or_spreads(visitor, node)
+                VisitAstPath::visit_jsx_attr_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
+    fn visit_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_attr_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_attr_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_closing_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_closing_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
+    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_closing_element(visitor, node)
+                VisitAstPath::visit_jsx_closing_fragment(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_closing_element(visitor, node)
+                VisitAstPath::visit_jsx_closing_fragment(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
+    fn visit_jsx_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_closing_fragment(visitor, node)
+                VisitAstPath::visit_jsx_element(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_closing_fragment(visitor, node)
+                VisitAstPath::visit_jsx_element(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
+    fn visit_jsx_element_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_element_child(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_element_child(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
+    fn visit_jsx_element_childs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXElementChild],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_element_child(visitor, node)
+                VisitAstPath::visit_jsx_element_childs(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_element_child(visitor, node)
+                VisitAstPath::visit_jsx_element_childs(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
+    fn visit_jsx_element_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_element_childs(visitor, node)
+                VisitAstPath::visit_jsx_element_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_element_childs(visitor, node)
+                VisitAstPath::visit_jsx_element_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
+    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXEmptyExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_element_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_empty_expr(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_element_name(visitor, node)
+                VisitAstPath::visit_jsx_empty_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
+    fn visit_jsx_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_empty_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_empty_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
+    fn visit_jsx_expr_container<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExprContainer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_expr_container(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_expr_container(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
+    fn visit_jsx_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_expr_container(visitor, node)
+                VisitAstPath::visit_jsx_fragment(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_expr_container(visitor, node)
+                VisitAstPath::visit_jsx_fragment(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
+    fn visit_jsx_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXMemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_fragment(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_fragment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_member_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_member_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
+    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXNamespacedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_member_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_member_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_namespaced_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_namespaced_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
+    fn visit_jsx_object<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXObject,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_namespaced_name(visitor, node)
+                VisitAstPath::visit_jsx_object(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_namespaced_name(visitor, node)
+                VisitAstPath::visit_jsx_object(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
+    fn visit_jsx_opening_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_object(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_object(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_opening_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_jsx_opening_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
+    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_opening_element(visitor, node)
+                VisitAstPath::visit_jsx_opening_fragment(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_opening_element(visitor, node)
+                VisitAstPath::visit_jsx_opening_fragment(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
+    fn visit_jsx_spread_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXSpreadChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_jsx_opening_fragment(visitor, node)
+                VisitAstPath::visit_jsx_spread_child(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_opening_fragment(visitor, node)
+                VisitAstPath::visit_jsx_spread_child(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
+    fn visit_jsx_text<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXText,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_spread_child(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_jsx_text(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_jsx_spread_child(visitor, node)
+                VisitAstPath::visit_jsx_text(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
+    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_text(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_text(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_key(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_key(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key) {
+    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValuePatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_key(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_key(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_key_value_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_key_value_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
+    fn visit_key_value_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValueProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_key_value_pat_prop(visitor, node)
+                VisitAstPath::visit_key_value_prop(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_key_value_pat_prop(visitor, node)
+                VisitAstPath::visit_key_value_prop(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
+    fn visit_labeled_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LabeledStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_key_value_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_key_value_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_labeled_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_labeled_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
+    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_labeled_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_labeled_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_lit(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_lit(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit) {
+    fn visit_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_member_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_member_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
+    fn visit_member_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_member_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_member_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_member_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_member_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
+    fn visit_meta_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_member_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_member_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_meta_prop_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_meta_prop_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
+    fn visit_meta_prop_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_meta_prop_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_meta_prop_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_meta_prop_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_meta_prop_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
+    fn visit_method_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_meta_prop_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_meta_prop_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_method_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_method_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
+    fn visit_method_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_method_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_method_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_method_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_method_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
+    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_method_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_method_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_module(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_module(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module) {
+    fn visit_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_module_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_module_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
+    fn visit_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleExportName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_module_export_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_module_export_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
+    fn visit_module_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_module_export_name(visitor, node)
+                VisitAstPath::visit_module_item(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_module_export_name(visitor, node)
+                VisitAstPath::visit_module_item(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
+    fn visit_module_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ModuleItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module_item(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module_item(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_module_items(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_module_items(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
+    fn visit_named_export<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedExport,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module_items(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module_items(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_named_export(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_named_export(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
+    fn visit_new_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NewExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_named_export(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_named_export(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_new_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_new_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
+    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_new_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_new_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_null(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_null(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null) {
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_null(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_null(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_number(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_number(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
+    fn visit_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_number(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_object_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_object_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
+    fn visit_object_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_object_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_object_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_object_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
+    fn visit_object_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_object_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_object_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_object_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
+    fn visit_object_pat_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ObjectPatProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_object_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_object_pat_props(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_object_pat_props(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
+    fn visit_opt_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Accessibility>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_pat_props(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_accessibility(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_object_pat_props(visitor, node)
+                VisitAstPath::visit_opt_accessibility(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_accessibility(visitor, node)
+                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_accessibility(visitor, node)
+                VisitAstPath::visit_opt_atom(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
+    fn visit_opt_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<BlockStmt>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_block_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_block_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_block_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_block_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
+    fn visit_opt_call<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptCall,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_call(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_call(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_call(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_call(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
+    fn visit_opt_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<CatchClause>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_catch_clause(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_catch_clause(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_catch_clause(visitor, node)
+                VisitAstPath::visit_opt_catch_clause(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
+    fn visit_opt_chain_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_chain_base(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_chain_base(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_chain_base(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_chain_base(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
+    fn visit_opt_chain_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_chain_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_chain_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_chain_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_chain_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
+    fn visit_opt_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Expr>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
+    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ExprOrSpread>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_expr_or_spread(visitor, node)
+                VisitAstPath::visit_opt_expr_or_spread(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_expr_or_spread(visitor, node)
+                VisitAstPath::visit_opt_expr_or_spread(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
+    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_expr_or_spreads(visitor, node)
+                VisitAstPath::visit_opt_expr_or_spreads(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_expr_or_spreads(visitor, node)
+                VisitAstPath::visit_opt_expr_or_spreads(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
+    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXAttrValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_jsx_attr_value(visitor, node)
+                VisitAstPath::visit_opt_jsx_attr_value(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_jsx_attr_value(visitor, node)
+                VisitAstPath::visit_opt_jsx_attr_value(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
+    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXClosingElement>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_jsx_closing_element(visitor, node)
+                VisitAstPath::visit_opt_jsx_closing_element(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_jsx_closing_element(visitor, node)
+                VisitAstPath::visit_opt_jsx_closing_element(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
+    fn visit_opt_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ModuleExportName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_module_export_name(visitor, node)
+                VisitAstPath::visit_opt_module_export_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_module_export_name(visitor, node)
+                VisitAstPath::visit_opt_module_export_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
+    fn visit_opt_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ObjectLit>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_object_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_object_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_object_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_object_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
+    fn visit_opt_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Pat>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
+    fn visit_opt_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_common::Span>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
+    fn visit_opt_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Stmt>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
+    fn visit_opt_str<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Str>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_str(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_str(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_str(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_str(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
+    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TruePlusMinus>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_true_plus_minus(visitor, node)
+                VisitAstPath::visit_opt_true_plus_minus(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_true_plus_minus(visitor, node)
+                VisitAstPath::visit_opt_true_plus_minus(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
+    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsEntityName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_ts_entity_name(visitor, node)
+                VisitAstPath::visit_opt_ts_entity_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_ts_entity_name(visitor, node)
+                VisitAstPath::visit_opt_ts_entity_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
+    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsNamespaceBody>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_ts_namespace_body(visitor, node)
+                VisitAstPath::visit_opt_ts_namespace_body(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_ts_namespace_body(visitor, node)
+                VisitAstPath::visit_opt_ts_namespace_body(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
+    fn visit_opt_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ts_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ts_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_ts_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_ts_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
+    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ts_type_ann(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ts_type_ann(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_ts_type_ann(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_ts_type_ann(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
+    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_ts_type_param_decl(visitor, node)
+                VisitAstPath::visit_opt_ts_type_param_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_ts_type_param_decl(visitor, node)
+                VisitAstPath::visit_opt_ts_type_param_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_instantiation(
+    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        node: &'ast Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_ts_type_param_instantiation(visitor, node)
+                VisitAstPath::visit_opt_ts_type_param_instantiation(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_ts_type_param_instantiation(visitor, node)
+                VisitAstPath::visit_opt_ts_type_param_instantiation(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
+    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<VarDeclOrExpr>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_var_decl_or_expr(visitor, node)
+                VisitAstPath::visit_opt_var_decl_or_expr(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_var_decl_or_expr(visitor, node)
+                VisitAstPath::visit_opt_var_decl_or_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
+    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<ExprOrSpread>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_opt_vec_expr_or_spreads(visitor, node)
+                VisitAstPath::visit_opt_vec_expr_or_spreads(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_opt_vec_expr_or_spreads(visitor, node)
+                VisitAstPath::visit_opt_vec_expr_or_spreads(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
+    fn visit_opt_vec_pats<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<Pat>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_vec_pats(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_vec_pats(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_opt_vec_pats(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_opt_vec_pats(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param) {
+    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_param(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
+    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParamOrTsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_param_or_ts_param_prop(visitor, node)
+                VisitAstPath::visit_param_or_ts_param_prop(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_param_or_ts_param_prop(visitor, node)
+                VisitAstPath::visit_param_or_ts_param_prop(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
+    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ParamOrTsParamProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_param_or_ts_param_props(visitor, node)
+                VisitAstPath::visit_param_or_ts_param_props(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_param_or_ts_param_props(visitor, node)
+                VisitAstPath::visit_param_or_ts_param_props(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
+    fn visit_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Param],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_params(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
+    fn visit_paren_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParenExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_paren_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_paren_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_paren_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_paren_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat) {
+    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_pat(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_pat(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
+    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_pats(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_pats(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_pats(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_pats(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
+    fn visit_private_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_private_method(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_private_method(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_private_method(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_private_method(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
+    fn visit_private_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_private_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_private_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_private_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_private_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
+    fn visit_private_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_private_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_private_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_private_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_private_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program) {
+    fn visit_program<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Program,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_program(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_program(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_program(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_program(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop) {
+    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_prop(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
+    fn visit_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_prop_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_prop_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
+    fn visit_prop_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_prop_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_prop_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
+    fn visit_prop_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PropOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_prop_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_prop_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex) {
+    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_regex(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_regex(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_regex(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_regex(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
+    fn visit_rest_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RestPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_rest_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_rest_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_rest_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_rest_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
+    fn visit_return_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ReturnStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_return_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_return_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_return_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_return_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script) {
+    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_script(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_script(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_script(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_script(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
+    fn visit_seq_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SeqExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_seq_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_seq_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_seq_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_seq_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
+    fn visit_setter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_setter_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_setter_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_setter_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_setter_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
+    fn visit_simple_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleAssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_simple_assign_target(visitor, node)
+                VisitAstPath::visit_simple_assign_target(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_simple_assign_target(visitor, node)
+                VisitAstPath::visit_simple_assign_target(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_span(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_span(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
+    fn visit_spread_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SpreadElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_spread_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_spread_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_spread_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_spread_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
+    fn visit_static_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StaticBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_static_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_static_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_static_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_static_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
+    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_stmt(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
+    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_stmts(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_stmts(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_stmts(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_stmts(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_str(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_str(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_str(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super) {
+    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_super(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_super(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_super(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_super(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
+    fn visit_super_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_super_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_super_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_super_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_super_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
+    fn visit_super_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_super_prop_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_super_prop_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_super_prop_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_super_prop_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
+    fn visit_switch_case<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchCase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_switch_case(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_switch_case(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_switch_case(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_switch_case(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
+    fn visit_switch_cases<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SwitchCase],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_switch_cases(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_switch_cases(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_switch_cases(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_switch_cases(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
+    fn visit_switch_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_switch_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_switch_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_switch_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_switch_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
+    fn visit_syntax_context<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::SyntaxContext,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_syntax_context(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_syntax_context(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_syntax_context(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_syntax_context(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
+    fn visit_tagged_tpl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TaggedTpl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tagged_tpl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tagged_tpl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_tagged_tpl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_tagged_tpl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
+    fn visit_this_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThisExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_this_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_this_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_this_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_this_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
+    fn visit_throw_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThrowStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_throw_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_throw_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_throw_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_throw_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
+    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tpl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tpl(visitor, node),
+            swc_visit::Either::Left(visitor) => VisitAstPath::visit_tpl(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => VisitAstPath::visit_tpl(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
+    fn visit_tpl_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TplElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tpl_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tpl_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_tpl_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_tpl_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
+    fn visit_tpl_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TplElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tpl_elements(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tpl_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_tpl_elements(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_tpl_elements(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
+    fn visit_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TruePlusMinus,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_true_plus_minus(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_true_plus_minus(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_true_plus_minus(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_true_plus_minus(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
+    fn visit_try_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TryStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_try_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_try_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_try_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_try_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
+    fn visit_ts_array_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsArrayType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_array_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_array_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_array_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_array_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
+    fn visit_ts_as_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsAsExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_as_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_as_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_as_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_as_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
+    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsCallSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_call_signature_decl(visitor, node)
+                VisitAstPath::visit_ts_call_signature_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_call_signature_decl(visitor, node)
+                VisitAstPath::visit_ts_call_signature_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
+    fn visit_ts_conditional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConditionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_conditional_type(visitor, node)
+                VisitAstPath::visit_ts_conditional_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_conditional_type(visitor, node)
+                VisitAstPath::visit_ts_conditional_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
+    fn visit_ts_const_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_const_assertion(visitor, node)
+                VisitAstPath::visit_ts_const_assertion(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_const_assertion(visitor, node)
+                VisitAstPath::visit_ts_const_assertion(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
+    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_construct_signature_decl(visitor, node)
+                VisitAstPath::visit_ts_construct_signature_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_construct_signature_decl(visitor, node)
+                VisitAstPath::visit_ts_construct_signature_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
+    fn visit_ts_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_constructor_type(visitor, node)
+                VisitAstPath::visit_ts_constructor_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_constructor_type(visitor, node)
+                VisitAstPath::visit_ts_constructor_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
+    fn visit_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEntityName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_entity_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_entity_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_entity_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_entity_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
+    fn visit_ts_enum_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_enum_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_enum_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_enum_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_enum_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
+    fn visit_ts_enum_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_enum_member(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_enum_member(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_enum_member(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_enum_member(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
+    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMemberId,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_enum_member_id(visitor, node)
+                VisitAstPath::visit_ts_enum_member_id(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_enum_member_id(visitor, node)
+                VisitAstPath::visit_ts_enum_member_id(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
+    fn visit_ts_enum_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsEnumMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_enum_members(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_enum_members(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_enum_members(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_enum_members(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
+    fn visit_ts_export_assignment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExportAssignment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_export_assignment(visitor, node)
+                VisitAstPath::visit_ts_export_assignment(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_export_assignment(visitor, node)
+                VisitAstPath::visit_ts_export_assignment(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
+    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExprWithTypeArgs,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_expr_with_type_args(visitor, node)
+                VisitAstPath::visit_ts_expr_with_type_args(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_expr_with_type_args(visitor, node)
+                VisitAstPath::visit_ts_expr_with_type_args(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
+    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsExprWithTypeArgs],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_expr_with_type_argss(visitor, node)
+                VisitAstPath::visit_ts_expr_with_type_argss(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_expr_with_type_argss(visitor, node)
+                VisitAstPath::visit_ts_expr_with_type_argss(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
+    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExternalModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_external_module_ref(visitor, node)
+                VisitAstPath::visit_ts_external_module_ref(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_external_module_ref(visitor, node)
+                VisitAstPath::visit_ts_external_module_ref(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
+    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnOrConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_fn_or_constructor_type(visitor, node)
+                VisitAstPath::visit_ts_fn_or_constructor_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_fn_or_constructor_type(visitor, node)
+                VisitAstPath::visit_ts_fn_or_constructor_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
+    fn visit_ts_fn_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_fn_param(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_fn_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_fn_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_fn_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
+    fn visit_ts_fn_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsFnParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_fn_params(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_fn_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_fn_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_fn_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
+    fn visit_ts_fn_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_fn_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_fn_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_fn_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_fn_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
+    fn visit_ts_getter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsGetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_getter_signature(visitor, node)
+                VisitAstPath::visit_ts_getter_signature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_getter_signature(visitor, node)
+                VisitAstPath::visit_ts_getter_signature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
+    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportEqualsDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_import_equals_decl(visitor, node)
+                VisitAstPath::visit_ts_import_equals_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_import_equals_decl(visitor, node)
+                VisitAstPath::visit_ts_import_equals_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
+    fn visit_ts_import_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_import_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_import_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_import_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_import_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
+    fn visit_ts_index_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_index_signature(visitor, node)
+                VisitAstPath::visit_ts_index_signature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_index_signature(visitor, node)
+                VisitAstPath::visit_ts_index_signature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
+    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexedAccessType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_indexed_access_type(visitor, node)
+                VisitAstPath::visit_ts_indexed_access_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_indexed_access_type(visitor, node)
+                VisitAstPath::visit_ts_indexed_access_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
+    fn visit_ts_infer_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInferType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_infer_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_infer_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_infer_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_infer_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
+    fn visit_ts_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_instantiation(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_instantiation(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_instantiation(visitor, node)
+                VisitAstPath::visit_ts_instantiation(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
+    fn visit_ts_interface_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_interface_body(visitor, node)
+                VisitAstPath::visit_ts_interface_body(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_interface_body(visitor, node)
+                VisitAstPath::visit_ts_interface_body(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
+    fn visit_ts_interface_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_interface_decl(visitor, node)
+                VisitAstPath::visit_ts_interface_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_interface_decl(visitor, node)
+                VisitAstPath::visit_ts_interface_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
+    fn visit_ts_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_intersection_type(visitor, node)
+                VisitAstPath::visit_ts_intersection_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_intersection_type(visitor, node)
+                VisitAstPath::visit_ts_intersection_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
+    fn visit_ts_keyword_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_keyword_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_keyword_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_keyword_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_keyword_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
+    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordTypeKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_keyword_type_kind(visitor, node)
+                VisitAstPath::visit_ts_keyword_type_kind(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_keyword_type_kind(visitor, node)
+                VisitAstPath::visit_ts_keyword_type_kind(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
+    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
+    fn visit_ts_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_lit_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_lit_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_lit_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_lit_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
+    fn visit_ts_mapped_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMappedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_mapped_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_mapped_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_mapped_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_mapped_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
+    fn visit_ts_method_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMethodSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_method_signature(visitor, node)
+                VisitAstPath::visit_ts_method_signature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_method_signature(visitor, node)
+                VisitAstPath::visit_ts_method_signature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
+    fn visit_ts_module_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_module_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_module_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
+    fn visit_ts_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_module_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_module_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
+    fn visit_ts_module_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_module_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_module_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
+    fn visit_ts_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_ref(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_ref(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_module_ref(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_module_ref(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
+    fn visit_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_namespace_body(visitor, node)
+                VisitAstPath::visit_ts_namespace_body(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_namespace_body(visitor, node)
+                VisitAstPath::visit_ts_namespace_body(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
+    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_namespace_decl(visitor, node)
+                VisitAstPath::visit_ts_namespace_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_namespace_decl(visitor, node)
+                VisitAstPath::visit_ts_namespace_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
+    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_namespace_export_decl(visitor, node)
+                VisitAstPath::visit_ts_namespace_export_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_namespace_export_decl(visitor, node)
+                VisitAstPath::visit_ts_namespace_export_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
+    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNonNullExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_non_null_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_non_null_expr(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_non_null_expr(visitor, node)
+                VisitAstPath::visit_ts_non_null_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
+    fn visit_ts_optional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsOptionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_optional_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_optional_type(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_optional_type(visitor, node)
+                VisitAstPath::visit_ts_optional_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
+    fn visit_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_param_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_param_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_param_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_param_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
+    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamPropParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_param_prop_param(visitor, node)
+                VisitAstPath::visit_ts_param_prop_param(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_param_prop_param(visitor, node)
+                VisitAstPath::visit_ts_param_prop_param(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
+    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParenthesizedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_parenthesized_type(visitor, node)
+                VisitAstPath::visit_ts_parenthesized_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_parenthesized_type(visitor, node)
+                VisitAstPath::visit_ts_parenthesized_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
+    fn visit_ts_property_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsPropertySignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_property_signature(visitor, node)
+                VisitAstPath::visit_ts_property_signature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_property_signature(visitor, node)
+                VisitAstPath::visit_ts_property_signature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
+    fn visit_ts_qualified_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsQualifiedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_qualified_name(visitor, node)
+                VisitAstPath::visit_ts_qualified_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_qualified_name(visitor, node)
+                VisitAstPath::visit_ts_qualified_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
+    fn visit_ts_rest_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsRestType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_rest_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_rest_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_rest_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_rest_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
+    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSatisfiesExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_satisfies_expr(visitor, node)
+                VisitAstPath::visit_ts_satisfies_expr(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_satisfies_expr(visitor, node)
+                VisitAstPath::visit_ts_satisfies_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
+    fn visit_ts_setter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_setter_signature(visitor, node)
+                VisitAstPath::visit_ts_setter_signature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_setter_signature(visitor, node)
+                VisitAstPath::visit_ts_setter_signature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
+    fn visit_ts_this_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_this_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_this_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_this_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_this_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
+    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisTypeOrIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_this_type_or_ident(visitor, node)
+                VisitAstPath::visit_ts_this_type_or_ident(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_this_type_or_ident(visitor, node)
+                VisitAstPath::visit_ts_this_type_or_ident(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
+    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTplLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_tpl_lit_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_tpl_lit_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_tpl_lit_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_tpl_lit_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
+    fn visit_ts_tuple_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_tuple_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_tuple_element(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_tuple_element(visitor, node)
+                VisitAstPath::visit_ts_tuple_element(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
+    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTupleElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_tuple_elements(visitor, node)
+                VisitAstPath::visit_ts_tuple_elements(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_tuple_elements(visitor, node)
+                VisitAstPath::visit_ts_tuple_elements(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
+    fn visit_ts_tuple_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_tuple_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_tuple_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_tuple_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_tuple_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
+    fn visit_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
+    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAliasDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_type_alias_decl(visitor, node)
+                VisitAstPath::visit_ts_type_alias_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_alias_decl(visitor, node)
+                VisitAstPath::visit_ts_type_alias_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
+    fn visit_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAnn,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_ann(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_ann(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_ann(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type_ann(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
+    fn visit_ts_type_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_type_assertion(visitor, node)
+                VisitAstPath::visit_ts_type_assertion(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_assertion(visitor, node)
+                VisitAstPath::visit_ts_type_assertion(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
+    fn visit_ts_type_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
+    fn visit_ts_type_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_elements(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_elements(visitor, node)
+                VisitAstPath::visit_ts_type_elements(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
+    fn visit_ts_type_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
+    fn visit_ts_type_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_operator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_operator(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_operator(visitor, node)
+                VisitAstPath::visit_ts_type_operator(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
+    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperatorOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_type_operator_op(visitor, node)
+                VisitAstPath::visit_ts_type_operator_op(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_operator_op(visitor, node)
+                VisitAstPath::visit_ts_type_operator_op(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
+    fn visit_ts_type_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_param(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
+    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_type_param_decl(visitor, node)
+                VisitAstPath::visit_ts_type_param_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_param_decl(visitor, node)
+                VisitAstPath::visit_ts_type_param_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
+    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_type_param_instantiation(visitor, node)
+                VisitAstPath::visit_ts_type_param_instantiation(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_param_instantiation(visitor, node)
+                VisitAstPath::visit_ts_type_param_instantiation(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
+    fn visit_ts_type_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_params(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
+    fn visit_ts_type_predicate<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypePredicate,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_type_predicate(visitor, node)
+                VisitAstPath::visit_ts_type_predicate(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_predicate(visitor, node)
+                VisitAstPath::visit_ts_type_predicate(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
+    fn visit_ts_type_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_query(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
+    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQueryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_type_query_expr(visitor, node)
+                VisitAstPath::visit_ts_type_query_expr(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_type_query_expr(visitor, node)
+                VisitAstPath::visit_ts_type_query_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
+    fn visit_ts_type_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_ref(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_ref(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_type_ref(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_type_ref(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
+    fn visit_ts_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<TsType>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_types(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_types(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
+    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionOrIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMut::visit_mut_ts_union_or_intersection_type(visitor, node)
+                VisitAstPath::visit_ts_union_or_intersection_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_ts_union_or_intersection_type(visitor, node)
+                VisitAstPath::visit_ts_union_or_intersection_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
+    fn visit_ts_union_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_union_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_union_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_ts_union_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_ts_union_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
+    fn visit_unary_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_unary_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_unary_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_unary_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_unary_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
+    fn visit_unary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_unary_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_unary_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_unary_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_unary_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
+    fn visit_update_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_update_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_update_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_update_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_update_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
+    fn visit_update_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_update_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_update_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_update_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_update_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
+    fn visit_using_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UsingDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_using_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_using_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_using_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_using_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
+    fn visit_var_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_var_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_var_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
+    fn visit_var_decl_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_decl_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_decl_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_var_decl_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_var_decl_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
+    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_decl_or_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_var_decl_or_expr(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitMut::visit_mut_var_decl_or_expr(visitor, node)
+                VisitAstPath::visit_var_decl_or_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
+    fn visit_var_declarator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclarator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_declarator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_declarator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_var_declarator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_var_declarator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
+    fn visit_var_declarators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [VarDeclarator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_declarators(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_declarators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_var_declarators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_var_declarators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
+    fn visit_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_while_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_while_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_while_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_while_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
+    fn visit_with_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WithStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_with_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_with_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_with_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_with_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
+    fn visit_yield_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast YieldExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_yield_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_yield_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitAstPath::visit_yield_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitAstPath::visit_yield_expr(visitor, node, __ast_path)
+            }
         }
     }
 }
-impl<V> VisitMut for ::swc_visit::Optional<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitAstPath for ::swc_visit::Optional<V>
 where
-    V: VisitMut,
+    V: VisitAstPath,
 {
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
+    fn visit_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Accessibility,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_accessibility(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_accessibility(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
+    fn visit_array_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_array_lit(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_array_lit(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
+    fn visit_array_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrayPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_array_pat(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_array_pat(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
+    fn visit_arrow_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ArrowExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_arrow_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_arrow_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
+    fn visit_assign_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_assign_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_assign_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
+    fn visit_assign_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_assign_op(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_assign_op(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
+    fn visit_assign_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_assign_pat(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_assign_pat(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
+    fn visit_assign_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_assign_pat_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_assign_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
+    fn visit_assign_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_assign_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_assign_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
+    fn visit_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_assign_target(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_assign_target(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
+    fn visit_assign_target_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AssignTargetPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_assign_target_pat(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_assign_target_pat(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+    fn visit_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_atoms::Atom,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_atom(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_atom(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
+    fn visit_auto_accessor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AutoAccessor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_auto_accessor(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_auto_accessor(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
+    fn visit_await_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast AwaitExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_await_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_await_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
+    fn visit_big_int<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigInt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_big_int(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_big_int(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
+    fn visit_big_int_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BigIntValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_big_int_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_big_int_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
+    fn visit_bin_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_bin_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_bin_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
+    fn visit_binary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BinaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_binary_op(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_binary_op(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
+    fn visit_binding_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BindingIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_binding_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_binding_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
+    fn visit_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_block_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_block_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
+    fn visit_block_stmt_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BlockStmtOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_block_stmt_or_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_block_stmt_or_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool) {
+    fn visit_bool<'ast: 'r, 'r>(&mut self, node: &'ast Bool, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_bool(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_bool(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
+    fn visit_break_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast BreakStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_break_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_break_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
+    fn visit_call_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CallExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_call_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_call_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee) {
+    fn visit_callee<'ast: 'r, 'r>(&mut self, node: &'ast Callee, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_callee(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_callee(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
+    fn visit_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CatchClause,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_catch_clause(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_catch_clause(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class) {
+    fn visit_class<'ast: 'r, 'r>(&mut self, node: &'ast Class, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
+    fn visit_class_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
+    fn visit_class_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
+    fn visit_class_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class_member(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class_member(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
+    fn visit_class_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ClassMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class_members(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class_members(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
+    fn visit_class_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class_method(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class_method(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
+    fn visit_class_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ClassProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_class_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_class_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
+    fn visit_computed_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ComputedPropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_computed_prop_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_computed_prop_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
+    fn visit_cond_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast CondExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_cond_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_cond_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
+    fn visit_constructor<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Constructor,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_constructor(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_constructor(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
+    fn visit_continue_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ContinueStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_continue_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_continue_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
+    fn visit_debugger_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DebuggerStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_debugger_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_debugger_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl) {
+    fn visit_decl<'ast: 'r, 'r>(&mut self, node: &'ast Decl, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
+    fn visit_decorator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Decorator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_decorator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_decorator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
+    fn visit_decorators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Decorator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_decorators(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_decorators(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
+    fn visit_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_default_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_default_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
+    fn visit_do_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast DoWhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_do_while_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_do_while_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
+    fn visit_empty_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EmptyStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_empty_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_empty_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
+    fn visit_es_version<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast EsVersion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_es_version(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_es_version(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
+    fn visit_export_all<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportAll,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_all(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_all(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
+    fn visit_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
+    fn visit_export_default_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_default_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_default_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
+    fn visit_export_default_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_default_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_default_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
+    fn visit_export_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_default_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_default_specifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
+    fn visit_export_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_named_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_named_specifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
+    fn visit_export_namespace_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportNamespaceSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_namespace_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_namespace_specifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
+    fn visit_export_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_specifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
+    fn visit_export_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_export_specifiers(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_export_specifiers(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr) {
+    fn visit_expr<'ast: 'r, 'r>(&mut self, node: &'ast Expr, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
+    fn visit_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_expr_or_spread(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_expr_or_spread(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
+    fn visit_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ExprOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_expr_or_spreads(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_expr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
+    fn visit_expr_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ExprStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_expr_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_expr_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
+    fn visit_exprs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<Expr>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_exprs(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_exprs(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
+    fn visit_fn_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_fn_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_fn_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
+    fn visit_fn_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast FnExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_fn_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_fn_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
+    fn visit_for_head<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForHead,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_for_head(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_for_head(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
+    fn visit_for_in_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForInStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_for_in_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_for_in_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
+    fn visit_for_of_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForOfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_for_of_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_for_of_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
+    fn visit_for_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ForStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_for_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_for_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function) {
+    fn visit_function<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Function,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_function(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_function(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
+    fn visit_getter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast GetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_getter_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_getter_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident) {
+    fn visit_ident<'ast: 'r, 'r>(&mut self, node: &'ast Ident, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
+    fn visit_ident_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IdentName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ident_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ident_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
+    fn visit_if_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast IfStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_if_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_if_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import) {
+    fn visit_import<'ast: 'r, 'r>(&mut self, node: &'ast Import, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
+    fn visit_import_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
+    fn visit_import_default_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportDefaultSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_default_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_default_specifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
+    fn visit_import_named_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportNamedSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_named_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_named_specifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
+    fn visit_import_phase<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportPhase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_phase(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_phase(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
+    fn visit_import_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_specifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
+    fn visit_import_specifiers<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportSpecifier],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_specifiers(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_specifiers(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
+    fn visit_import_star_as_specifier<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportStarAsSpecifier,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_star_as_specifier(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_star_as_specifier(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
+    fn visit_import_with<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWith,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_with(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_with(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
+    fn visit_import_with_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ImportWithItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_with_item(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_with_item(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
+    fn visit_import_with_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ImportWithItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_import_with_items(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_import_with_items(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
+    fn visit_invalid<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Invalid,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_invalid(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_invalid(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
+    fn visit_jsx_attr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_attr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_attr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
+    fn visit_jsx_attr_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_attr_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_attr_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
+    fn visit_jsx_attr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_attr_or_spread(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_attr_or_spread(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
+    fn visit_jsx_attr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXAttrOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_attr_or_spreads(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_attr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
+    fn visit_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXAttrValue,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_attr_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_attr_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
+    fn visit_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_closing_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_closing_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
+    fn visit_jsx_closing_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXClosingFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_closing_fragment(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_closing_fragment(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
+    fn visit_jsx_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
+    fn visit_jsx_element_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_element_child(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_element_child(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
+    fn visit_jsx_element_childs<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [JSXElementChild],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_element_childs(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_element_childs(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
+    fn visit_jsx_element_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXElementName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_element_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_element_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
+    fn visit_jsx_empty_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXEmptyExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_empty_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_empty_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
+    fn visit_jsx_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
+    fn visit_jsx_expr_container<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXExprContainer,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_expr_container(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_expr_container(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
+    fn visit_jsx_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_fragment(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_fragment(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
+    fn visit_jsx_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXMemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_member_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_member_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
+    fn visit_jsx_namespaced_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXNamespacedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_namespaced_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_namespaced_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
+    fn visit_jsx_object<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXObject,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_object(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_object(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
+    fn visit_jsx_opening_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_opening_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_opening_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
+    fn visit_jsx_opening_fragment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXOpeningFragment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_opening_fragment(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_opening_fragment(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
+    fn visit_jsx_spread_child<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXSpreadChild,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_spread_child(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_spread_child(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
+    fn visit_jsx_text<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast JSXText,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_jsx_text(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_jsx_text(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key) {
+    fn visit_key<'ast: 'r, 'r>(&mut self, node: &'ast Key, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_key(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_key(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
+    fn visit_key_value_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValuePatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_key_value_pat_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_key_value_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
+    fn visit_key_value_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast KeyValueProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_key_value_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_key_value_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
+    fn visit_labeled_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast LabeledStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_labeled_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_labeled_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit) {
+    fn visit_lit<'ast: 'r, 'r>(&mut self, node: &'ast Lit, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_lit(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_lit(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
+    fn visit_member_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_member_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_member_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
+    fn visit_member_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MemberProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_member_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_member_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
+    fn visit_meta_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_meta_prop_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_meta_prop_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
+    fn visit_meta_prop_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MetaPropKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_meta_prop_kind(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_meta_prop_kind(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
+    fn visit_method_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_method_kind(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_method_kind(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
+    fn visit_method_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast MethodProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_method_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_method_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module) {
+    fn visit_module<'ast: 'r, 'r>(&mut self, node: &'ast Module, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_module(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_module(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
+    fn visit_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_module_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_module_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
+    fn visit_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleExportName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_module_export_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_module_export_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
+    fn visit_module_item<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ModuleItem,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_module_item(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_module_item(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
+    fn visit_module_items<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ModuleItem],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_module_items(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_module_items(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
+    fn visit_named_export<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NamedExport,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_named_export(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_named_export(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
+    fn visit_new_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast NewExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_new_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_new_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null) {
+    fn visit_null<'ast: 'r, 'r>(&mut self, node: &'ast Null, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_null(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_null(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number) {
+    fn visit_number<'ast: 'r, 'r>(&mut self, node: &'ast Number, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_number(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_number(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
+    fn visit_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_object_lit(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_object_lit(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
+    fn visit_object_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_object_pat(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_object_pat(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
+    fn visit_object_pat_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ObjectPatProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_object_pat_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_object_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
+    fn visit_object_pat_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ObjectPatProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_object_pat_props(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_object_pat_props(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
+    fn visit_opt_accessibility<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Accessibility>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_accessibility(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_accessibility(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+    fn visit_opt_atom<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_atoms::Atom>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_atom(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_atom(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
+    fn visit_opt_block_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<BlockStmt>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_block_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_block_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
+    fn visit_opt_call<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptCall,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_call(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_call(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
+    fn visit_opt_catch_clause<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<CatchClause>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_catch_clause(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_catch_clause(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
+    fn visit_opt_chain_base<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainBase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_chain_base(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_chain_base(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
+    fn visit_opt_chain_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast OptChainExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_chain_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_chain_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
+    fn visit_opt_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Expr>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
+    fn visit_opt_expr_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ExprOrSpread>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_expr_or_spread(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_expr_or_spread(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
+    fn visit_opt_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_expr_or_spreads(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_expr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+    fn visit_opt_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Ident>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
+    fn visit_opt_jsx_attr_value<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXAttrValue>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_jsx_attr_value(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_jsx_attr_value(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
+    fn visit_opt_jsx_closing_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<JSXClosingElement>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_jsx_closing_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_jsx_closing_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
+    fn visit_opt_module_export_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<ModuleExportName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_module_export_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_module_export_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
+    fn visit_opt_object_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<ObjectLit>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_object_lit(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_object_lit(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
+    fn visit_opt_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Pat>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_pat(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_pat(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
+    fn visit_opt_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<swc_common::Span>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_span(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_span(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
+    fn visit_opt_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Stmt>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
+    fn visit_opt_str<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<Str>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_str(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_str(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
+    fn visit_opt_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TruePlusMinus>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_true_plus_minus(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_true_plus_minus(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
+    fn visit_opt_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsEntityName>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ts_entity_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ts_entity_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
+    fn visit_opt_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<TsNamespaceBody>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ts_namespace_body(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ts_namespace_body(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
+    fn visit_opt_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsType>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ts_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ts_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
+    fn visit_opt_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ts_type_ann(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ts_type_ann(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
+    fn visit_opt_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ts_type_param_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ts_type_param_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_instantiation(
+    fn visit_opt_ts_type_param_instantiation<'ast: 'r, 'r>(
         &mut self,
-        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        node: &'ast Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstNodePath<'r>,
     ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
+    fn visit_opt_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Option<VarDeclOrExpr>,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_var_decl_or_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_var_decl_or_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
+    fn visit_opt_vec_expr_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<ExprOrSpread>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
+    fn visit_opt_vec_pats<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Option<Pat>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_opt_vec_pats(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_opt_vec_pats(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param) {
+    fn visit_param<'ast: 'r, 'r>(&mut self, node: &'ast Param, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_param(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_param(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
+    fn visit_param_or_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParamOrTsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_param_or_ts_param_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_param_or_ts_param_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
+    fn visit_param_or_ts_param_props<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [ParamOrTsParamProp],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_param_or_ts_param_props(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_param_or_ts_param_props(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
+    fn visit_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Param],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_params(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_params(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
+    fn visit_paren_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ParenExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_paren_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_paren_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat) {
+    fn visit_pat<'ast: 'r, 'r>(&mut self, node: &'ast Pat, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pat(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pat(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
+    fn visit_pats<'ast: 'r, 'r>(&mut self, node: &'ast [Pat], __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_pats(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_pats(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
+    fn visit_private_method<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateMethod,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_private_method(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_private_method(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
+    fn visit_private_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_private_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_private_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
+    fn visit_private_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PrivateProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_private_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_private_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program) {
+    fn visit_program<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast Program,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_program(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_program(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop) {
+    fn visit_prop<'ast: 'r, 'r>(&mut self, node: &'ast Prop, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
+    fn visit_prop_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_prop_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_prop_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
+    fn visit_prop_or_spread<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast PropOrSpread,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_prop_or_spread(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_prop_or_spread(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
+    fn visit_prop_or_spreads<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [PropOrSpread],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_prop_or_spreads(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_prop_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex) {
+    fn visit_regex<'ast: 'r, 'r>(&mut self, node: &'ast Regex, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_regex(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_regex(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
+    fn visit_rest_pat<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast RestPat,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_rest_pat(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_rest_pat(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
+    fn visit_return_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ReturnStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_return_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_return_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script) {
+    fn visit_script<'ast: 'r, 'r>(&mut self, node: &'ast Script, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_script(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_script(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
+    fn visit_seq_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SeqExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_seq_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_seq_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
+    fn visit_setter_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SetterProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_setter_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_setter_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
+    fn visit_simple_assign_target<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SimpleAssignTarget,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_simple_assign_target(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_simple_assign_target(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+    fn visit_span<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::Span,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_span(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_span(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
+    fn visit_spread_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SpreadElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_spread_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_spread_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
+    fn visit_static_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast StaticBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_static_block(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_static_block(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
+    fn visit_stmt<'ast: 'r, 'r>(&mut self, node: &'ast Stmt, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
+    fn visit_stmts<'ast: 'r, 'r>(&mut self, node: &'ast [Stmt], __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_stmts(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_stmts(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str) {
+    fn visit_str<'ast: 'r, 'r>(&mut self, node: &'ast Str, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_str(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_str(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super) {
+    fn visit_super<'ast: 'r, 'r>(&mut self, node: &'ast Super, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_super(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_super(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
+    fn visit_super_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_super_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_super_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
+    fn visit_super_prop_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SuperPropExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_super_prop_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_super_prop_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
+    fn visit_switch_case<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchCase,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_switch_case(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_switch_case(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
+    fn visit_switch_cases<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [SwitchCase],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_switch_cases(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_switch_cases(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
+    fn visit_switch_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast SwitchStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_switch_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_switch_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
+    fn visit_syntax_context<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast swc_common::SyntaxContext,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_syntax_context(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_syntax_context(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
+    fn visit_tagged_tpl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TaggedTpl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_tagged_tpl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_tagged_tpl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
+    fn visit_this_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThisExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_this_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_this_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
+    fn visit_throw_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast ThrowStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_throw_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_throw_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
+    fn visit_tpl<'ast: 'r, 'r>(&mut self, node: &'ast Tpl, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_tpl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_tpl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
+    fn visit_tpl_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TplElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_tpl_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_tpl_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
+    fn visit_tpl_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TplElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_tpl_elements(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_tpl_elements(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
+    fn visit_true_plus_minus<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TruePlusMinus,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_true_plus_minus(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_true_plus_minus(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
+    fn visit_try_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TryStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_try_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_try_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
+    fn visit_ts_array_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsArrayType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_array_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_array_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
+    fn visit_ts_as_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsAsExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_as_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_as_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
+    fn visit_ts_call_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsCallSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_call_signature_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_call_signature_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
+    fn visit_ts_conditional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConditionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_conditional_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_conditional_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
+    fn visit_ts_const_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_const_assertion(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_const_assertion(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
+    fn visit_ts_construct_signature_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructSignatureDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_construct_signature_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_construct_signature_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
+    fn visit_ts_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_constructor_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_constructor_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
+    fn visit_ts_entity_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEntityName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_entity_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_entity_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
+    fn visit_ts_enum_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_enum_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_enum_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
+    fn visit_ts_enum_member<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMember,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_enum_member(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_enum_member(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
+    fn visit_ts_enum_member_id<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsEnumMemberId,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_enum_member_id(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_enum_member_id(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
+    fn visit_ts_enum_members<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsEnumMember],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_enum_members(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_enum_members(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
+    fn visit_ts_export_assignment<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExportAssignment,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_export_assignment(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_export_assignment(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
+    fn visit_ts_expr_with_type_args<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExprWithTypeArgs,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_expr_with_type_args(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_expr_with_type_args(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
+    fn visit_ts_expr_with_type_argss<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsExprWithTypeArgs],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_expr_with_type_argss(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_expr_with_type_argss(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
+    fn visit_ts_external_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsExternalModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_external_module_ref(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_external_module_ref(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
+    fn visit_ts_fn_or_constructor_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnOrConstructorType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_fn_or_constructor_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
+    fn visit_ts_fn_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_fn_param(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_fn_param(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
+    fn visit_ts_fn_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsFnParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_fn_params(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_fn_params(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
+    fn visit_ts_fn_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsFnType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_fn_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_fn_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
+    fn visit_ts_getter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsGetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_getter_signature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_getter_signature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
+    fn visit_ts_import_equals_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportEqualsDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_import_equals_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_import_equals_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
+    fn visit_ts_import_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsImportType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_import_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_import_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
+    fn visit_ts_index_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_index_signature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_index_signature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
+    fn visit_ts_indexed_access_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIndexedAccessType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_indexed_access_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_indexed_access_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
+    fn visit_ts_infer_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInferType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_infer_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_infer_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
+    fn visit_ts_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_instantiation(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_instantiation(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
+    fn visit_ts_interface_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_interface_body(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_interface_body(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
+    fn visit_ts_interface_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsInterfaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_interface_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_interface_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
+    fn visit_ts_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_intersection_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_intersection_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
+    fn visit_ts_keyword_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_keyword_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_keyword_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
+    fn visit_ts_keyword_type_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsKeywordTypeKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_keyword_type_kind(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_keyword_type_kind(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
+    fn visit_ts_lit<'ast: 'r, 'r>(&mut self, node: &'ast TsLit, __ast_path: &mut AstNodePath<'r>) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_lit(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_lit(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
+    fn visit_ts_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_lit_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_lit_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
+    fn visit_ts_mapped_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMappedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_mapped_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_mapped_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
+    fn visit_ts_method_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsMethodSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_method_signature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_method_signature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
+    fn visit_ts_module_block<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleBlock,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_module_block(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_module_block(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
+    fn visit_ts_module_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_module_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_module_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
+    fn visit_ts_module_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_module_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_module_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
+    fn visit_ts_module_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsModuleRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_module_ref(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_module_ref(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
+    fn visit_ts_namespace_body<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceBody,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_namespace_body(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_namespace_body(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
+    fn visit_ts_namespace_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_namespace_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_namespace_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
+    fn visit_ts_namespace_export_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNamespaceExportDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_namespace_export_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_namespace_export_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
+    fn visit_ts_non_null_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsNonNullExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_non_null_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_non_null_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
+    fn visit_ts_optional_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsOptionalType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_optional_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_optional_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
+    fn visit_ts_param_prop<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamProp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_param_prop(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_param_prop(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
+    fn visit_ts_param_prop_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParamPropParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_param_prop_param(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_param_prop_param(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
+    fn visit_ts_parenthesized_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsParenthesizedType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_parenthesized_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_parenthesized_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
+    fn visit_ts_property_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsPropertySignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_property_signature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_property_signature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
+    fn visit_ts_qualified_name<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsQualifiedName,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_qualified_name(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_qualified_name(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
+    fn visit_ts_rest_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsRestType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_rest_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_rest_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
+    fn visit_ts_satisfies_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSatisfiesExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_satisfies_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_satisfies_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
+    fn visit_ts_setter_signature<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsSetterSignature,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_setter_signature(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_setter_signature(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
+    fn visit_ts_this_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_this_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_this_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
+    fn visit_ts_this_type_or_ident<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsThisTypeOrIdent,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_this_type_or_ident(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_this_type_or_ident(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
+    fn visit_ts_tpl_lit_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTplLitType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_tpl_lit_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_tpl_lit_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
+    fn visit_ts_tuple_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_tuple_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_tuple_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
+    fn visit_ts_tuple_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTupleElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_tuple_elements(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_tuple_elements(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
+    fn visit_ts_tuple_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTupleType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_tuple_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_tuple_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
+    fn visit_ts_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
+    fn visit_ts_type_alias_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAliasDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_alias_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_alias_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
+    fn visit_ts_type_ann<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAnn,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_ann(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_ann(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
+    fn visit_ts_type_assertion<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeAssertion,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_assertion(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_assertion(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
+    fn visit_ts_type_element<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeElement,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_element(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_element(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
+    fn visit_ts_type_elements<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeElement],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_elements(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_elements(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
+    fn visit_ts_type_lit<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeLit,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_lit(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_lit(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
+    fn visit_ts_type_operator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_operator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_operator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
+    fn visit_ts_type_operator_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeOperatorOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_operator_op(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_operator_op(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
+    fn visit_ts_type_param<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParam,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_param(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_param(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
+    fn visit_ts_type_param_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_param_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_param_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
+    fn visit_ts_type_param_instantiation<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeParamInstantiation,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_param_instantiation(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_param_instantiation(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
+    fn visit_ts_type_params<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [TsTypeParam],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_params(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_params(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
+    fn visit_ts_type_predicate<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypePredicate,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_predicate(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_predicate(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
+    fn visit_ts_type_query<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQuery,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_query(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_query(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
+    fn visit_ts_type_query_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeQueryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_query_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_query_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
+    fn visit_ts_type_ref<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsTypeRef,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_type_ref(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_type_ref(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
+    fn visit_ts_types<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [Box<TsType>],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_types(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_types(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
+    fn visit_ts_union_or_intersection_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionOrIntersectionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_union_or_intersection_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_union_or_intersection_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
+    fn visit_ts_union_type<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast TsUnionType,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_ts_union_type(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_ts_union_type(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
+    fn visit_unary_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_unary_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_unary_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
+    fn visit_unary_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UnaryOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_unary_op(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_unary_op(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
+    fn visit_update_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_update_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_update_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
+    fn visit_update_op<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UpdateOp,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_update_op(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_update_op(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
+    fn visit_using_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast UsingDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_using_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_using_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
+    fn visit_var_decl<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDecl,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_var_decl(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_var_decl(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
+    fn visit_var_decl_kind<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclKind,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_var_decl_kind(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_var_decl_kind(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
+    fn visit_var_decl_or_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclOrExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_var_decl_or_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_var_decl_or_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
+    fn visit_var_declarator<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast VarDeclarator,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_var_declarator(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_var_declarator(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
+    fn visit_var_declarators<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast [VarDeclarator],
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_var_declarators(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_var_declarators(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
+    fn visit_while_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WhileStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_while_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_while_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
+    fn visit_with_stmt<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast WithStmt,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_with_stmt(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_with_stmt(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
+    fn visit_yield_expr<'ast: 'r, 'r>(
+        &mut self,
+        node: &'ast YieldExpr,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         if self.enabled {
-            <V as VisitMut>::visit_mut_yield_expr(&mut self.visitor, node)
+            <V as VisitAstPath>::visit_yield_expr(&mut self.visitor, node, __ast_path)
         } else {
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitMutWith<V: ?Sized + VisitMut> {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait VisitWithAstPath<V: ?Sized + VisitAstPath> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_mut_with(&mut self, visitor: &mut V);
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    );
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_mut_children_with(&mut self, visitor: &mut V);
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    );
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Accessibility {
-    #[doc = "Calls [VisitMut`::visit_mut_accessibility`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_accessibility(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Accessibility {
+    #[doc = "Calls [VisitAstPath`::visit_accessibility`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_accessibility(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Accessibility::Public => {}
             Accessibility::Protected => {}
@@ -60204,32 +32846,68 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Accessibility {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrayLit {
-    #[doc = "Calls [VisitMut`::visit_mut_array_lit`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_array_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrayLit {
+    #[doc = "Calls [VisitAstPath`::visit_array_lit`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_array_lit(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ArrayLit { span, elems } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayLit(
+                        self,
+                        self::fields::ArrayLitField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Option<ExprOrSpread>> as VisitMutWith<V>>::visit_mut_with(elems, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayLit(
+                        self,
+                        self::fields::ArrayLitField::Elems(usize::MAX),
+                    ));
+                    <Vec<Option<ExprOrSpread>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        elems,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrayPat {
-    #[doc = "Calls [VisitMut`::visit_mut_array_pat`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_array_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrayPat {
+    #[doc = "Calls [VisitAstPath`::visit_array_pat`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_array_pat(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ArrayPat {
                 span,
@@ -60238,25 +32916,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrayPat {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayPat(
+                        self,
+                        self::fields::ArrayPatField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Option<Pat>> as VisitMutWith<V>>::visit_mut_with(elems, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayPat(
+                        self,
+                        self::fields::ArrayPatField::Elems(usize::MAX),
+                    ));
+                    <Vec<Option<Pat>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        elems,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrayPat(
+                        self,
+                        self::fields::ArrayPatField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrowExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_arrow_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_arrow_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ArrowExpr {
+    #[doc = "Calls [VisitAstPath`::visit_arrow_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_arrow_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ArrowExpr {
                 span,
@@ -60269,40 +32981,92 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrowExpr {
                 return_type,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
+                        self,
+                        self::fields::ArrowExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
+                        self,
+                        self::fields::ArrowExprField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Pat> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
+                        self,
+                        self::fields::ArrowExprField::Params(usize::MAX),
+                    ));
+                    <Vec<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<BlockStmtOrExpr> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
+                        self,
+                        self::fields::ArrowExprField::Body,
+                    ));
+                    <Box<BlockStmtOrExpr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
+                        self,
+                        self::fields::ArrowExprField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ArrowExpr(
+                        self,
+                        self::fields::ArrowExprField::ReturnType,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         return_type,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_assign_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_assign_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignExpr {
+    #[doc = "Calls [VisitAstPath`::visit_assign_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AssignExpr {
                 span,
@@ -60311,28 +33075,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignExpr {
                 right,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
+                        self,
+                        self::fields::AssignExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <AssignOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
+                        self,
+                        self::fields::AssignExprField::Op,
+                    ));
+                    <AssignOp as VisitWithAstPath<V>>::visit_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <AssignTarget as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
+                        self,
+                        self::fields::AssignExprField::Left,
+                    ));
+                    <AssignTarget as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignExpr(
+                        self,
+                        self::fields::AssignExprField::Right,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignOp {
-    #[doc = "Calls [VisitMut`::visit_mut_assign_op`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_assign_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignOp {
+    #[doc = "Calls [VisitAstPath`::visit_assign_op`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_op(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AssignOp::Assign => {}
             AssignOp::AddAssign => {}
@@ -60353,116 +33159,288 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignOp {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignPat {
-    #[doc = "Calls [VisitMut`::visit_mut_assign_pat`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_assign_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignPat {
+    #[doc = "Calls [VisitAstPath`::visit_assign_pat`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_pat(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AssignPat { span, left, right } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPat(
+                        self,
+                        self::fields::AssignPatField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPat(
+                        self,
+                        self::fields::AssignPatField::Left,
+                    ));
+                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPat(
+                        self,
+                        self::fields::AssignPatField::Right,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignPatProp {
-    #[doc = "Calls [VisitMut`::visit_mut_assign_pat_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_assign_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignPatProp {
+    #[doc = "Calls [VisitAstPath`::visit_assign_pat_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_pat_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AssignPatProp { span, key, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPatProp(
+                        self,
+                        self::fields::AssignPatPropField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <BindingIdent as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPatProp(
+                        self,
+                        self::fields::AssignPatPropField::Key,
+                    ));
+                    <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignPatProp(
+                        self,
+                        self::fields::AssignPatPropField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignProp {
-    #[doc = "Calls [VisitMut`::visit_mut_assign_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_assign_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignProp {
+    #[doc = "Calls [VisitAstPath`::visit_assign_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AssignProp { span, key, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignProp(
+                        self,
+                        self::fields::AssignPropField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignProp(
+                        self,
+                        self::fields::AssignPropField::Key,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignProp(
+                        self,
+                        self::fields::AssignPropField::Value,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignTarget {
-    #[doc = "Calls [VisitMut`::visit_mut_assign_target`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_assign_target(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignTarget {
+    #[doc = "Calls [VisitAstPath`::visit_assign_target`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_target(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AssignTarget::Simple { 0: _field_0 } => {
-                <SimpleAssignTarget as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTarget(
+                    self,
+                    self::fields::AssignTargetField::Simple,
+                ));
+                <SimpleAssignTarget as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AssignTarget::Pat { 0: _field_0 } => {
-                <AssignTargetPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTarget(
+                    self,
+                    self::fields::AssignTargetField::Pat,
+                ));
+                <AssignTargetPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignTargetPat {
-    #[doc = "Calls [VisitMut`::visit_mut_assign_target_pat`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_assign_target_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AssignTargetPat {
+    #[doc = "Calls [VisitAstPath`::visit_assign_target_pat`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_assign_target_pat(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AssignTargetPat::Array { 0: _field_0 } => {
-                <ArrayPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTargetPat(
+                    self,
+                    self::fields::AssignTargetPatField::Array,
+                ));
+                <ArrayPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AssignTargetPat::Object { 0: _field_0 } => {
-                <ObjectPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTargetPat(
+                    self,
+                    self::fields::AssignTargetPatField::Object,
+                ));
+                <ObjectPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AssignTargetPat::Invalid { 0: _field_0 } => {
-                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AssignTargetPat(
+                    self,
+                    self::fields::AssignTargetPatField::Invalid,
+                ));
+                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AutoAccessor {
-    #[doc = "Calls [VisitMut`::visit_mut_auto_accessor`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_auto_accessor(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AutoAccessor {
+    #[doc = "Calls [VisitAstPath`::visit_auto_accessor`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_auto_accessor(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AutoAccessor {
                 span,
@@ -60477,78 +33455,193 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for AutoAccessor {
                 definite,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
+                        self,
+                        self::fields::AutoAccessorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Key as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
+                        self,
+                        self::fields::AutoAccessorField::Key,
+                    ));
+                    <Key as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
+                        self,
+                        self::fields::AutoAccessorField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
+                        self,
+                        self::fields::AutoAccessorField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
+                        self,
+                        self::fields::AutoAccessorField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AutoAccessor(
+                        self,
+                        self::fields::AutoAccessorField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
                         accessibility,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for AwaitExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_await_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_await_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for AwaitExpr {
+    #[doc = "Calls [VisitAstPath`::visit_await_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_await_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             AwaitExpr { span, arg } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AwaitExpr(
+                        self,
+                        self::fields::AwaitExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::AwaitExpr(
+                        self,
+                        self::fields::AwaitExprField::Arg,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BigInt {
-    #[doc = "Calls [VisitMut`::visit_mut_big_int`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_big_int(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BigInt {
+    #[doc = "Calls [VisitAstPath`::visit_big_int`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_big_int(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BigInt { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BigInt(
+                        self,
+                        self::fields::BigIntField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<BigIntValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BigInt(
+                        self,
+                        self::fields::BigIntField::Value,
+                    ));
+                    <Box<BigIntValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BigInt(
+                        self,
+                        self::fields::BigIntField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_bin_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_bin_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinExpr {
+    #[doc = "Calls [VisitAstPath`::visit_bin_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_bin_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BinExpr {
                 span,
@@ -60557,28 +33650,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinExpr {
                 right,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
+                        self,
+                        self::fields::BinExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <BinaryOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
+                        self,
+                        self::fields::BinExprField::Op,
+                    ));
+                    <BinaryOp as VisitWithAstPath<V>>::visit_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
+                        self,
+                        self::fields::BinExprField::Left,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BinExpr(
+                        self,
+                        self::fields::BinExprField::Right,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinaryOp {
-    #[doc = "Calls [VisitMut`::visit_mut_binary_op`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_binary_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BinaryOp {
+    #[doc = "Calls [VisitAstPath`::visit_binary_op`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_binary_op(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BinaryOp::EqEq => {}
             BinaryOp::NotEq => {}
@@ -60608,106 +33743,244 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinaryOp {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BindingIdent {
-    #[doc = "Calls [VisitMut`::visit_mut_binding_ident`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_binding_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BindingIdent {
+    #[doc = "Calls [VisitAstPath`::visit_binding_ident`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_binding_ident(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BindingIdent { id, type_ann } => {
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BindingIdent(
+                        self,
+                        self::fields::BindingIdentField::Id,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BindingIdent(
+                        self,
+                        self::fields::BindingIdentField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BlockStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_block_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_block_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BlockStmt {
+    #[doc = "Calls [VisitAstPath`::visit_block_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_block_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BlockStmt { span, ctxt, stmts } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmt(
+                        self,
+                        self::fields::BlockStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmt(
+                        self,
+                        self::fields::BlockStmtField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Stmt> as VisitMutWith<V>>::visit_mut_with(stmts, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmt(
+                        self,
+                        self::fields::BlockStmtField::Stmts(usize::MAX),
+                    ));
+                    <Vec<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        stmts,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
-}
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BlockStmtOrExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_block_stmt_or_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_block_stmt_or_expr(visitor, self)
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BlockStmtOrExpr {
+    #[doc = "Calls [VisitAstPath`::visit_block_stmt_or_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_block_stmt_or_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BlockStmtOrExpr::BlockStmt { 0: _field_0 } => {
-                <BlockStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmtOrExpr(
+                    self,
+                    self::fields::BlockStmtOrExprField::BlockStmt,
+                ));
+                <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             BlockStmtOrExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BlockStmtOrExpr(
+                    self,
+                    self::fields::BlockStmtOrExprField::Expr,
+                ));
+                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Bool {
-    #[doc = "Calls [VisitMut`::visit_mut_bool`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_bool(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Bool {
+    #[doc = "Calls [VisitAstPath`::visit_bool`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_bool(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Bool { span, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Bool(self, self::fields::BoolField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BreakStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_break_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_break_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BreakStmt {
+    #[doc = "Calls [VisitAstPath`::visit_break_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_break_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             BreakStmt { span, label } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BreakStmt(
+                        self,
+                        self::fields::BreakStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(label, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::BreakStmt(
+                        self,
+                        self::fields::BreakStmtField::Label,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CallExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_call_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_call_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CallExpr {
+    #[doc = "Calls [VisitAstPath`::visit_call_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_call_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CallExpr {
                 span,
@@ -60717,75 +33990,187 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for CallExpr {
                 type_args,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
+                        self,
+                        self::fields::CallExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
+                        self,
+                        self::fields::CallExprField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Callee as VisitMutWith<V>>::visit_mut_with(callee, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
+                        self,
+                        self::fields::CallExprField::Callee,
+                    ));
+                    <Callee as VisitWithAstPath<V>>::visit_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(args, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
+                        self,
+                        self::fields::CallExprField::Args(usize::MAX),
+                    ));
+                    <Vec<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
-                    )
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CallExpr(
+                        self,
+                        self::fields::CallExprField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Callee {
-    #[doc = "Calls [VisitMut`::visit_mut_callee`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_callee(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Callee {
+    #[doc = "Calls [VisitAstPath`::visit_callee`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_callee(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Callee::Super { 0: _field_0 } => {
-                <Super as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Callee(
+                    self,
+                    self::fields::CalleeField::Super,
+                ));
+                <Super as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Callee::Import { 0: _field_0 } => {
-                <Import as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Callee(
+                    self,
+                    self::fields::CalleeField::Import,
+                ));
+                <Import as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Callee::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Callee(
+                    self,
+                    self::fields::CalleeField::Expr,
+                ));
+                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CatchClause {
-    #[doc = "Calls [VisitMut`::visit_mut_catch_clause`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_catch_clause(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CatchClause {
+    #[doc = "Calls [VisitAstPath`::visit_catch_clause`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_catch_clause(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CatchClause { span, param, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CatchClause(
+                        self,
+                        self::fields::CatchClauseField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Pat> as VisitMutWith<V>>::visit_mut_with(param, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CatchClause(
+                        self,
+                        self::fields::CatchClauseField::Param,
+                    ));
+                    <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <BlockStmt as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CatchClause(
+                        self,
+                        self::fields::CatchClauseField::Body,
+                    ));
+                    <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Class {
-    #[doc = "Calls [VisitMut`::visit_mut_class`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Class {
+    #[doc = "Calls [VisitAstPath`::visit_class`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Class {
                 span,
@@ -60799,48 +34184,110 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Class {
                 implements,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ClassMember> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::Body(usize::MAX),
+                    ));
+                    <Vec<ClassMember> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(super_class, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::SuperClass,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        super_class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        super_type_params,
-                        visitor,
-                    )
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::SuperTypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (super_type_params , visitor , & mut * __ast_path)
                 };
                 {
-                    <Vec<TsExprWithTypeArgs> as VisitMutWith<V>>::visit_mut_with(
-                        implements, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Class(
+                        self,
+                        self::fields::ClassField::Implements(usize::MAX),
+                    ));
+                    <Vec<TsExprWithTypeArgs> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        implements,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_class_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassDecl {
+    #[doc = "Calls [VisitAstPath`::visit_class_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ClassDecl {
                 ident,
@@ -60848,79 +34295,213 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassDecl {
                 class,
             } => {
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(ident, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassDecl(
+                        self,
+                        self::fields::ClassDeclField::Ident,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Class> as VisitMutWith<V>>::visit_mut_with(class, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassDecl(
+                        self,
+                        self::fields::ClassDeclField::Class,
+                    ));
+                    <Box<Class> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_class_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassExpr {
+    #[doc = "Calls [VisitAstPath`::visit_class_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ClassExpr { ident, class } => {
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(ident, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassExpr(
+                        self,
+                        self::fields::ClassExprField::Ident,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Class> as VisitMutWith<V>>::visit_mut_with(class, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassExpr(
+                        self,
+                        self::fields::ClassExprField::Class,
+                    ));
+                    <Box<Class> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassMember {
-    #[doc = "Calls [VisitMut`::visit_mut_class_member`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class_member(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassMember {
+    #[doc = "Calls [VisitAstPath`::visit_class_member`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_member(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ClassMember::Constructor { 0: _field_0 } => {
-                <Constructor as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::Constructor,
+                ));
+                <Constructor as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::Method { 0: _field_0 } => {
-                <ClassMethod as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::Method,
+                ));
+                <ClassMethod as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::PrivateMethod { 0: _field_0 } => {
-                <PrivateMethod as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::PrivateMethod,
+                ));
+                <PrivateMethod as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::ClassProp { 0: _field_0 } => {
-                <ClassProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::ClassProp,
+                ));
+                <ClassProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::PrivateProp { 0: _field_0 } => {
-                <PrivateProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::PrivateProp,
+                ));
+                <PrivateProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::TsIndexSignature { 0: _field_0 } => {
-                <TsIndexSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::TsIndexSignature,
+                ));
+                <TsIndexSignature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::Empty { 0: _field_0 } => {
-                <EmptyStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::Empty,
+                ));
+                <EmptyStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::StaticBlock { 0: _field_0 } => {
-                <StaticBlock as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::StaticBlock,
+                ));
+                <StaticBlock as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::AutoAccessor { 0: _field_0 } => {
-                <AutoAccessor as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMember(
+                    self,
+                    self::fields::ClassMemberField::AutoAccessor,
+                ));
+                <AutoAccessor as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassMethod {
-    #[doc = "Calls [VisitMut`::visit_mut_class_method`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class_method(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassMethod {
+    #[doc = "Calls [VisitAstPath`::visit_class_method`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_method(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ClassMethod {
                 span,
@@ -60934,34 +34515,81 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassMethod {
                 is_override,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
+                        self,
+                        self::fields::ClassMethodField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
+                        self,
+                        self::fields::ClassMethodField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
+                        self,
+                        self::fields::ClassMethodField::Function,
+                    ));
+                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MethodKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
+                        self,
+                        self::fields::ClassMethodField::Kind,
+                    ));
+                    <MethodKind as VisitWithAstPath<V>>::visit_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassMethod(
+                        self,
+                        self::fields::ClassMethodField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
                         accessibility,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassProp {
-    #[doc = "Calls [VisitMut`::visit_mut_class_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ClassProp {
+    #[doc = "Calls [VisitAstPath`::visit_class_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ClassProp {
                 span,
@@ -60979,56 +34607,137 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassProp {
                 definite,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
+                        self,
+                        self::fields::ClassPropField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
+                        self,
+                        self::fields::ClassPropField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
+                        self,
+                        self::fields::ClassPropField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
+                        self,
+                        self::fields::ClassPropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
+                        self,
+                        self::fields::ClassPropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ClassProp(
+                        self,
+                        self::fields::ClassPropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
                         accessibility,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComputedPropName {
-    #[doc = "Calls [VisitMut`::visit_mut_computed_prop_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_computed_prop_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ComputedPropName {
+    #[doc = "Calls [VisitAstPath`::visit_computed_prop_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_computed_prop_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ComputedPropName { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComputedPropName(
+                        self,
+                        self::fields::ComputedPropNameField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ComputedPropName(
+                        self,
+                        self::fields::ComputedPropNameField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for CondExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_cond_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_cond_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for CondExpr {
+    #[doc = "Calls [VisitAstPath`::visit_cond_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_cond_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             CondExpr {
                 span,
@@ -61037,28 +34746,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for CondExpr {
                 alt,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
+                        self,
+                        self::fields::CondExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
+                        self,
+                        self::fields::CondExprField::Test,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(cons, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
+                        self,
+                        self::fields::CondExprField::Cons,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(alt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::CondExpr(
+                        self,
+                        self::fields::CondExprField::Alt,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        alt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Constructor {
-    #[doc = "Calls [VisitMut`::visit_mut_constructor`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_constructor(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Constructor {
+    #[doc = "Calls [VisitAstPath`::visit_constructor`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_constructor(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Constructor {
                 span,
@@ -61070,184 +34821,461 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Constructor {
                 is_optional,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
+                        self,
+                        self::fields::ConstructorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
+                        self,
+                        self::fields::ConstructorField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
+                        self,
+                        self::fields::ConstructorField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ParamOrTsParamProp> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
+                        self,
+                        self::fields::ConstructorField::Params(usize::MAX),
+                    ));
+                    <Vec<ParamOrTsParamProp> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
+                        self,
+                        self::fields::ConstructorField::Body,
+                    ));
+                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Constructor(
+                        self,
+                        self::fields::ConstructorField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
                         accessibility,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContinueStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_continue_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_continue_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ContinueStmt {
+    #[doc = "Calls [VisitAstPath`::visit_continue_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_continue_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ContinueStmt { span, label } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContinueStmt(
+                        self,
+                        self::fields::ContinueStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(label, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ContinueStmt(
+                        self,
+                        self::fields::ContinueStmtField::Label,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DebuggerStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_debugger_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_debugger_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DebuggerStmt {
+    #[doc = "Calls [VisitAstPath`::visit_debugger_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_debugger_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DebuggerStmt { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DebuggerStmt(
+                        self,
+                        self::fields::DebuggerStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Decl {
-    #[doc = "Calls [VisitMut`::visit_mut_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Decl {
+    #[doc = "Calls [VisitAstPath`::visit_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Decl::Class { 0: _field_0 } => {
-                <ClassDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Class));
+                <ClassDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::Fn { 0: _field_0 } => {
-                <FnDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Fn));
+                <FnDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::Var { 0: _field_0 } => {
-                <Box<VarDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Var));
+                <Box<VarDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::Using { 0: _field_0 } => {
-                <Box<UsingDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Decl(self, self::fields::DeclField::Using));
+                <Box<UsingDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsInterface { 0: _field_0 } => {
-                <Box<TsInterfaceDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
+                    self,
+                    self::fields::DeclField::TsInterface,
+                ));
+                <Box<TsInterfaceDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsTypeAlias { 0: _field_0 } => {
-                <Box<TsTypeAliasDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
+                    self,
+                    self::fields::DeclField::TsTypeAlias,
+                ));
+                <Box<TsTypeAliasDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsEnum { 0: _field_0 } => {
-                <Box<TsEnumDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
+                    self,
+                    self::fields::DeclField::TsEnum,
+                ));
+                <Box<TsEnumDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsModule { 0: _field_0 } => {
-                <Box<TsModuleDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decl(
+                    self,
+                    self::fields::DeclField::TsModule,
+                ));
+                <Box<TsModuleDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Decorator {
-    #[doc = "Calls [VisitMut`::visit_mut_decorator`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_decorator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Decorator {
+    #[doc = "Calls [VisitAstPath`::visit_decorator`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_decorator(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Decorator { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decorator(
+                        self,
+                        self::fields::DecoratorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Decorator(
+                        self,
+                        self::fields::DecoratorField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DefaultDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_default_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_default_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DefaultDecl {
+    #[doc = "Calls [VisitAstPath`::visit_default_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_default_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DefaultDecl::Class { 0: _field_0 } => {
-                <ClassExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DefaultDecl(
+                    self,
+                    self::fields::DefaultDeclField::Class,
+                ));
+                <ClassExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DefaultDecl::Fn { 0: _field_0 } => {
-                <FnExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DefaultDecl(
+                    self,
+                    self::fields::DefaultDeclField::Fn,
+                ));
+                <FnExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DefaultDecl::TsInterfaceDecl { 0: _field_0 } => {
-                <Box<TsInterfaceDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DefaultDecl(
+                    self,
+                    self::fields::DefaultDeclField::TsInterfaceDecl,
+                ));
+                <Box<TsInterfaceDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for DoWhileStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_do_while_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_do_while_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for DoWhileStmt {
+    #[doc = "Calls [VisitAstPath`::visit_do_while_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_do_while_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             DoWhileStmt { span, test, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DoWhileStmt(
+                        self,
+                        self::fields::DoWhileStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DoWhileStmt(
+                        self,
+                        self::fields::DoWhileStmtField::Test,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::DoWhileStmt(
+                        self,
+                        self::fields::DoWhileStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for EmptyStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_empty_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_empty_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for EmptyStmt {
+    #[doc = "Calls [VisitAstPath`::visit_empty_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_empty_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             EmptyStmt { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::EmptyStmt(
+                        self,
+                        self::fields::EmptyStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for EsVersion {
-    #[doc = "Calls [VisitMut`::visit_mut_es_version`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_es_version(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for EsVersion {
+    #[doc = "Calls [VisitAstPath`::visit_es_version`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_es_version(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             EsVersion::Es3 => {}
             EsVersion::Es5 => {}
@@ -61263,13 +35291,23 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for EsVersion {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportAll {
-    #[doc = "Calls [VisitMut`::visit_mut_export_all`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_all(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportAll {
+    #[doc = "Calls [VisitAstPath`::visit_export_all`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_all(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportAll {
                 span,
@@ -61278,98 +35316,233 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportAll {
                 with,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportAll(
+                        self,
+                        self::fields::ExportAllField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Str> as VisitMutWith<V>>::visit_mut_with(src, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportAll(
+                        self,
+                        self::fields::ExportAllField::Src,
+                    ));
+                    <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<ObjectLit>> as VisitMutWith<V>>::visit_mut_with(with, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportAll(
+                        self,
+                        self::fields::ExportAllField::With,
+                    ));
+                    <Option<Box<ObjectLit>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_export_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDecl {
+    #[doc = "Calls [VisitAstPath`::visit_export_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportDecl { span, decl } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportDecl(
+                        self,
+                        self::fields::ExportDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Decl as VisitMutWith<V>>::visit_mut_with(decl, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportDecl(
+                        self,
+                        self::fields::ExportDeclField::Decl,
+                    ));
+                    <Decl as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDefaultDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_export_default_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_default_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDefaultDecl {
+    #[doc = "Calls [VisitAstPath`::visit_export_default_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportDefaultDecl { span, decl } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultDecl(
+                            self,
+                            self::fields::ExportDefaultDeclField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <DefaultDecl as VisitMutWith<V>>::visit_mut_with(decl, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultDecl(
+                            self,
+                            self::fields::ExportDefaultDeclField::Decl,
+                        ));
+                    <DefaultDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDefaultExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_export_default_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_default_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDefaultExpr {
+    #[doc = "Calls [VisitAstPath`::visit_export_default_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportDefaultExpr { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultExpr(
+                            self,
+                            self::fields::ExportDefaultExprField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultExpr(
+                            self,
+                            self::fields::ExportDefaultExprField::Expr,
+                        ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDefaultSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_export_default_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_default_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportDefaultSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_export_default_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_default_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportDefaultSpecifier { exported } => {
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(exported, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportDefaultSpecifier(
+                            self,
+                            self::fields::ExportDefaultSpecifierField::Exported,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        exported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportNamedSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_export_named_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_named_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportNamedSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_export_named_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_named_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportNamedSpecifier {
                 span,
@@ -61378,227 +35551,656 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportNamedSpecifier {
                 is_type_only,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportNamedSpecifier(
+                            self,
+                            self::fields::ExportNamedSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ModuleExportName as VisitMutWith<V>>::visit_mut_with(orig, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportNamedSpecifier(
+                            self,
+                            self::fields::ExportNamedSpecifierField::Orig,
+                        ));
+                    <ModuleExportName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        orig,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<ModuleExportName> as VisitMutWith<V>>::visit_mut_with(exported, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportNamedSpecifier(
+                            self,
+                            self::fields::ExportNamedSpecifierField::Exported,
+                        ));
+                    <Option<ModuleExportName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        exported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportNamespaceSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_export_namespace_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_namespace_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportNamespaceSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_export_namespace_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_namespace_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportNamespaceSpecifier { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportNamespaceSpecifier(
+                            self,
+                            self::fields::ExportNamespaceSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ModuleExportName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ExportNamespaceSpecifier(
+                            self,
+                            self::fields::ExportNamespaceSpecifierField::Name,
+                        ));
+                    <ModuleExportName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_export_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExportSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_export_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExportSpecifier::Namespace { 0: _field_0 } => {
-                <ExportNamespaceSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportSpecifier(
+                    self,
+                    self::fields::ExportSpecifierField::Namespace,
+                ));
+                <ExportNamespaceSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ExportSpecifier::Default { 0: _field_0 } => {
-                <ExportDefaultSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportSpecifier(
+                    self,
+                    self::fields::ExportSpecifierField::Default,
+                ));
+                <ExportDefaultSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ExportSpecifier::Named { 0: _field_0 } => {
-                <ExportNamedSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExportSpecifier(
+                    self,
+                    self::fields::ExportSpecifierField::Named,
+                ));
+                <ExportNamedSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Expr {
-    #[doc = "Calls [VisitMut`::visit_mut_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Expr {
+    #[doc = "Calls [VisitAstPath`::visit_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Expr::This { 0: _field_0 } => {
-                <ThisExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::This));
+                <ThisExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Array { 0: _field_0 } => {
-                <ArrayLit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Array));
+                <ArrayLit as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Object { 0: _field_0 } => {
-                <ObjectLit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Object,
+                ));
+                <ObjectLit as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Fn { 0: _field_0 } => {
-                <FnExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Fn));
+                <FnExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Unary { 0: _field_0 } => {
-                <UnaryExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Unary));
+                <UnaryExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Update { 0: _field_0 } => {
-                <UpdateExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Update,
+                ));
+                <UpdateExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Bin { 0: _field_0 } => {
-                <BinExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Bin));
+                <BinExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Assign { 0: _field_0 } => {
-                <AssignExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Assign,
+                ));
+                <AssignExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Member { 0: _field_0 } => {
-                <MemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Member,
+                ));
+                <MemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::SuperProp { 0: _field_0 } => {
-                <SuperPropExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::SuperProp,
+                ));
+                <SuperPropExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Cond { 0: _field_0 } => {
-                <CondExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Cond));
+                <CondExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Call { 0: _field_0 } => {
-                <CallExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Call));
+                <CallExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::New { 0: _field_0 } => {
-                <NewExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::New));
+                <NewExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Seq { 0: _field_0 } => {
-                <SeqExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Seq));
+                <SeqExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Ident));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Lit { 0: _field_0 } => {
-                <Lit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Lit));
+                <Lit as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Tpl { 0: _field_0 } => {
-                <Tpl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Tpl));
+                <Tpl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TaggedTpl { 0: _field_0 } => {
-                <TaggedTpl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::TaggedTpl,
+                ));
+                <TaggedTpl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Arrow { 0: _field_0 } => {
-                <ArrowExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Arrow));
+                <ArrowExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Class { 0: _field_0 } => {
-                <ClassExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Class));
+                <ClassExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Yield { 0: _field_0 } => {
-                <YieldExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Yield));
+                <YieldExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::MetaProp { 0: _field_0 } => {
-                <MetaPropExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::MetaProp,
+                ));
+                <MetaPropExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Await { 0: _field_0 } => {
-                <AwaitExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Await));
+                <AwaitExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Paren { 0: _field_0 } => {
-                <ParenExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::Paren));
+                <ParenExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXMember { 0: _field_0 } => {
-                <JSXMemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Jsxmember,
+                ));
+                <JSXMemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::JsxnamespacedName,
+                ));
+                <JSXNamespacedName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXEmpty { 0: _field_0 } => {
-                <JSXEmptyExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Jsxempty,
+                ));
+                <JSXEmptyExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Jsxelement,
+                ));
+                <Box<JSXElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Jsxfragment,
+                ));
+                <JSXFragment as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsTypeAssertion { 0: _field_0 } => {
-                <TsTypeAssertion as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::TsTypeAssertion,
+                ));
+                <TsTypeAssertion as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsConstAssertion { 0: _field_0 } => {
-                <TsConstAssertion as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::TsConstAssertion,
+                ));
+                <TsConstAssertion as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsNonNull { 0: _field_0 } => {
-                <TsNonNullExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::TsNonNull,
+                ));
+                <TsNonNullExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsAs { 0: _field_0 } => {
-                <TsAsExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Expr(self, self::fields::ExprField::TsAs));
+                <TsAsExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsInstantiation { 0: _field_0 } => {
-                <TsInstantiation as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::TsInstantiation,
+                ));
+                <TsInstantiation as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsSatisfies { 0: _field_0 } => {
-                <TsSatisfiesExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::TsSatisfies,
+                ));
+                <TsSatisfiesExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::PrivateName { 0: _field_0 } => {
-                <PrivateName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::PrivateName,
+                ));
+                <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::OptChain { 0: _field_0 } => {
-                <OptChainExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::OptChain,
+                ));
+                <OptChainExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Invalid { 0: _field_0 } => {
-                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Expr(
+                    self,
+                    self::fields::ExprField::Invalid,
+                ));
+                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExprOrSpread {
-    #[doc = "Calls [VisitMut`::visit_mut_expr_or_spread`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_expr_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExprOrSpread {
+    #[doc = "Calls [VisitAstPath`::visit_expr_or_spread`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_or_spread(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExprOrSpread { spread, expr } => {
                 {
-                    <Option<swc_common::Span> as VisitMutWith<V>>::visit_mut_with(spread, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprOrSpread(
+                        self,
+                        self::fields::ExprOrSpreadField::Spread,
+                    ));
+                    <Option<swc_common::Span> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        spread,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprOrSpread(
+                        self,
+                        self::fields::ExprOrSpreadField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExprStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_expr_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_expr_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ExprStmt {
+    #[doc = "Calls [VisitAstPath`::visit_expr_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ExprStmt { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprStmt(
+                        self,
+                        self::fields::ExprStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ExprStmt(
+                        self,
+                        self::fields::ExprStmtField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for FnDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_fn_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_fn_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FnDecl {
+    #[doc = "Calls [VisitAstPath`::visit_fn_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_fn_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             FnDecl {
                 ident,
@@ -61606,61 +36208,147 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for FnDecl {
                 function,
             } => {
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(ident, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnDecl(
+                        self,
+                        self::fields::FnDeclField::Ident,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnDecl(
+                        self,
+                        self::fields::FnDeclField::Function,
+                    ));
+                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for FnExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_fn_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_fn_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for FnExpr {
+    #[doc = "Calls [VisitAstPath`::visit_fn_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_fn_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             FnExpr { ident, function } => {
                 {
-                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(ident, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnExpr(
+                        self,
+                        self::fields::FnExprField::Ident,
+                    ));
+                    <Option<Ident> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::FnExpr(
+                        self,
+                        self::fields::FnExprField::Function,
+                    ));
+                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForHead {
-    #[doc = "Calls [VisitMut`::visit_mut_for_head`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_for_head(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForHead {
+    #[doc = "Calls [VisitAstPath`::visit_for_head`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_head(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForHead::VarDecl { 0: _field_0 } => {
-                <Box<VarDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForHead(
+                    self,
+                    self::fields::ForHeadField::VarDecl,
+                ));
+                <Box<VarDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForHead::UsingDecl { 0: _field_0 } => {
-                <Box<UsingDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForHead(
+                    self,
+                    self::fields::ForHeadField::UsingDecl,
+                ));
+                <Box<UsingDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForHead::Pat { 0: _field_0 } => {
-                <Box<Pat> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForHead(
+                    self,
+                    self::fields::ForHeadField::Pat,
+                ));
+                <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForInStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_for_in_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_for_in_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForInStmt {
+    #[doc = "Calls [VisitAstPath`::visit_for_in_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_in_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForInStmt {
                 span,
@@ -61669,28 +36357,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForInStmt {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
+                        self,
+                        self::fields::ForInStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ForHead as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
+                        self,
+                        self::fields::ForInStmtField::Left,
+                    ));
+                    <ForHead as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
+                        self,
+                        self::fields::ForInStmtField::Right,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForInStmt(
+                        self,
+                        self::fields::ForInStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForOfStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_for_of_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_for_of_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForOfStmt {
+    #[doc = "Calls [VisitAstPath`::visit_for_of_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_of_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForOfStmt {
                 span,
@@ -61700,28 +36430,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForOfStmt {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
+                        self,
+                        self::fields::ForOfStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ForHead as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
+                        self,
+                        self::fields::ForOfStmtField::Left,
+                    ));
+                    <ForHead as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
+                        self,
+                        self::fields::ForOfStmtField::Right,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForOfStmt(
+                        self,
+                        self::fields::ForOfStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_for_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_for_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ForStmt {
+    #[doc = "Calls [VisitAstPath`::visit_for_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_for_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ForStmt {
                 span,
@@ -61731,31 +36503,81 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForStmt {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
+                        self,
+                        self::fields::ForStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<VarDeclOrExpr> as VisitMutWith<V>>::visit_mut_with(init, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
+                        self,
+                        self::fields::ForStmtField::Init,
+                    ));
+                    <Option<VarDeclOrExpr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(test, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
+                        self,
+                        self::fields::ForStmtField::Test,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(update, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
+                        self,
+                        self::fields::ForStmtField::Update,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        update,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ForStmt(
+                        self,
+                        self::fields::ForStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Function {
-    #[doc = "Calls [VisitMut`::visit_mut_function`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Function {
+    #[doc = "Calls [VisitAstPath`::visit_function`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_function(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Function {
                 params,
@@ -61769,43 +36591,103 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Function {
                 return_type,
             } => {
                 {
-                    <Vec<Param> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Params(usize::MAX),
+                    ));
+                    <Vec<Param> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::Body,
+                    ));
+                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Function(
+                        self,
+                        self::fields::FunctionField::ReturnType,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         return_type,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for GetterProp {
-    #[doc = "Calls [VisitMut`::visit_mut_getter_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_getter_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for GetterProp {
+    #[doc = "Calls [VisitAstPath`::visit_getter_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_getter_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             GetterProp {
                 span,
@@ -61814,28 +36696,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for GetterProp {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
+                        self,
+                        self::fields::GetterPropField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
+                        self,
+                        self::fields::GetterPropField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
+                        self,
+                        self::fields::GetterPropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::GetterProp(
+                        self,
+                        self::fields::GetterPropField::Body,
+                    ));
+                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Ident {
-    #[doc = "Calls [VisitMut`::visit_mut_ident`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Ident {
+    #[doc = "Calls [VisitAstPath`::visit_ident`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ident(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Ident {
                 span,
@@ -61844,44 +36768,102 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Ident {
                 optional,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
+                        self,
+                        self::fields::IdentField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Ident(
+                        self,
+                        self::fields::IdentField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(sym, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Ident(self, self::fields::IdentField::Sym));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        sym,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for IdentName {
-    #[doc = "Calls [VisitMut`::visit_mut_ident_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ident_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for IdentName {
+    #[doc = "Calls [VisitAstPath`::visit_ident_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ident_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             IdentName { span, sym } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdentName(
+                        self,
+                        self::fields::IdentNameField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(sym, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IdentName(
+                        self,
+                        self::fields::IdentNameField::Sym,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        sym,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for IfStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_if_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_if_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for IfStmt {
+    #[doc = "Calls [VisitAstPath`::visit_if_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_if_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             IfStmt {
                 span,
@@ -61890,47 +36872,115 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for IfStmt {
                 alt,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
+                        self,
+                        self::fields::IfStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
+                        self,
+                        self::fields::IfStmtField::Test,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(cons, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
+                        self,
+                        self::fields::IfStmtField::Cons,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Stmt>> as VisitMutWith<V>>::visit_mut_with(alt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::IfStmt(
+                        self,
+                        self::fields::IfStmtField::Alt,
+                    ));
+                    <Option<Box<Stmt>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        alt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Import {
-    #[doc = "Calls [VisitMut`::visit_mut_import`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Import {
+    #[doc = "Calls [VisitAstPath`::visit_import`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Import { span, phase } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Import(
+                        self,
+                        self::fields::ImportField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ImportPhase as VisitMutWith<V>>::visit_mut_with(phase, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Import(
+                        self,
+                        self::fields::ImportField::Phase,
+                    ));
+                    <ImportPhase as VisitWithAstPath<V>>::visit_with_ast_path(
+                        phase,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_import_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportDecl {
+    #[doc = "Calls [VisitAstPath`::visit_import_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportDecl {
                 span,
@@ -61941,50 +36991,128 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportDecl {
                 phase,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
+                        self,
+                        self::fields::ImportDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ImportSpecifier> as VisitMutWith<V>>::visit_mut_with(specifiers, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
+                        self,
+                        self::fields::ImportDeclField::Specifiers(usize::MAX),
+                    ));
+                    <Vec<ImportSpecifier> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        specifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Str> as VisitMutWith<V>>::visit_mut_with(src, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
+                        self,
+                        self::fields::ImportDeclField::Src,
+                    ));
+                    <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<ObjectLit>> as VisitMutWith<V>>::visit_mut_with(with, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
+                        self,
+                        self::fields::ImportDeclField::With,
+                    ));
+                    <Option<Box<ObjectLit>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <ImportPhase as VisitMutWith<V>>::visit_mut_with(phase, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportDecl(
+                        self,
+                        self::fields::ImportDeclField::Phase,
+                    ));
+                    <ImportPhase as VisitWithAstPath<V>>::visit_with_ast_path(
+                        phase,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportDefaultSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_import_default_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_default_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportDefaultSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_import_default_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_default_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportDefaultSpecifier { span, local } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ImportDefaultSpecifier(
+                            self,
+                            self::fields::ImportDefaultSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(local, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ImportDefaultSpecifier(
+                            self,
+                            self::fields::ImportDefaultSpecifierField::Local,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportNamedSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_import_named_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_named_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportNamedSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_import_named_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_named_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportNamedSpecifier {
                 span,
@@ -61993,25 +37121,62 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportNamedSpecifier {
                 is_type_only,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ImportNamedSpecifier(
+                            self,
+                            self::fields::ImportNamedSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(local, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ImportNamedSpecifier(
+                            self,
+                            self::fields::ImportNamedSpecifierField::Local,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<ModuleExportName> as VisitMutWith<V>>::visit_mut_with(imported, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ImportNamedSpecifier(
+                            self,
+                            self::fields::ImportNamedSpecifierField::Imported,
+                        ));
+                    <Option<ModuleExportName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        imported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportPhase {
-    #[doc = "Calls [VisitMut`::visit_mut_import_phase`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_phase(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportPhase {
+    #[doc = "Calls [VisitAstPath`::visit_import_phase`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_phase(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportPhase::Evaluation => {}
             ImportPhase::Source => {}
@@ -62019,220 +37184,537 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportPhase {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_import_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_import_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportSpecifier::Named { 0: _field_0 } => {
-                <ImportNamedSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportSpecifier(
+                    self,
+                    self::fields::ImportSpecifierField::Named,
+                ));
+                <ImportNamedSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportSpecifier::Default { 0: _field_0 } => {
-                <ImportDefaultSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportSpecifier(
+                    self,
+                    self::fields::ImportSpecifierField::Default,
+                ));
+                <ImportDefaultSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportSpecifier::Namespace { 0: _field_0 } => {
-                <ImportStarAsSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportSpecifier(
+                    self,
+                    self::fields::ImportSpecifierField::Namespace,
+                ));
+                <ImportStarAsSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportStarAsSpecifier {
-    #[doc = "Calls [VisitMut`::visit_mut_import_star_as_specifier`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_star_as_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportStarAsSpecifier {
+    #[doc = "Calls [VisitAstPath`::visit_import_star_as_specifier`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_star_as_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportStarAsSpecifier { span, local } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ImportStarAsSpecifier(
+                            self,
+                            self::fields::ImportStarAsSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(local, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::ImportStarAsSpecifier(
+                            self,
+                            self::fields::ImportStarAsSpecifierField::Local,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportWith {
-    #[doc = "Calls [VisitMut`::visit_mut_import_with`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_with(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportWith {
+    #[doc = "Calls [VisitAstPath`::visit_import_with`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportWith { span, values } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWith(
+                        self,
+                        self::fields::ImportWithField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ImportWithItem> as VisitMutWith<V>>::visit_mut_with(values, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWith(
+                        self,
+                        self::fields::ImportWithField::Values(usize::MAX),
+                    ));
+                    <Vec<ImportWithItem> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        values,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportWithItem {
-    #[doc = "Calls [VisitMut`::visit_mut_import_with_item`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_with_item(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ImportWithItem {
+    #[doc = "Calls [VisitAstPath`::visit_import_with_item`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with_item(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ImportWithItem { key, value } => {
                 {
-                    <IdentName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWithItem(
+                        self,
+                        self::fields::ImportWithItemField::Key,
+                    ));
+                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Str as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ImportWithItem(
+                        self,
+                        self::fields::ImportWithItemField::Value,
+                    ));
+                    <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Invalid {
-    #[doc = "Calls [VisitMut`::visit_mut_invalid`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_invalid(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Invalid {
+    #[doc = "Calls [VisitAstPath`::visit_invalid`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_invalid(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Invalid { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Invalid(
+                        self,
+                        self::fields::InvalidField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttr {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_attr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttr {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_attr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXAttr { span, name, value } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttr(
+                        self,
+                        self::fields::JSXAttrField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <JSXAttrName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttr(
+                        self,
+                        self::fields::JSXAttrField::Name,
+                    ));
+                    <JSXAttrName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<JSXAttrValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttr(
+                        self,
+                        self::fields::JSXAttrField::Value,
+                    ));
+                    <Option<JSXAttrValue> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttrName {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_attr_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttrName {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXAttrName::Ident { 0: _field_0 } => {
-                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrName(
+                    self,
+                    self::fields::JSXAttrNameField::Ident,
+                ));
+                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrName::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrName(
+                    self,
+                    self::fields::JSXAttrNameField::JsxnamespacedName,
+                ));
+                <JSXNamespacedName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttrOrSpread {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_or_spread`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_attr_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttrOrSpread {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_or_spread`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_or_spread(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
-                <JSXAttr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrOrSpread(
+                    self,
+                    self::fields::JSXAttrOrSpreadField::Jsxattr,
+                ));
+                <JSXAttr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
-                <SpreadElement as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrOrSpread(
+                    self,
+                    self::fields::JSXAttrOrSpreadField::SpreadElement,
+                ));
+                <SpreadElement as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttrValue {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_value`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_attr_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXAttrValue {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_value`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_value(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXAttrValue::Lit { 0: _field_0 } => {
-                <Lit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
+                    self,
+                    self::fields::JSXAttrValueField::Lit,
+                ));
+                <Lit as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrValue::JSXExprContainer { 0: _field_0 } => {
-                <JSXExprContainer as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
+                    self,
+                    self::fields::JSXAttrValueField::JsxexprContainer,
+                ));
+                <JSXExprContainer as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrValue::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
+                    self,
+                    self::fields::JSXAttrValueField::Jsxelement,
+                ));
+                <Box<JSXElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrValue::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXAttrValue(
+                    self,
+                    self::fields::JSXAttrValueField::Jsxfragment,
+                ));
+                <JSXFragment as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXClosingElement {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_closing_element`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_closing_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXClosingElement {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_closing_element`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_closing_element(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXClosingElement { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXClosingElement(
+                            self,
+                            self::fields::JSXClosingElementField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <JSXElementName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXClosingElement(
+                            self,
+                            self::fields::JSXClosingElementField::Name,
+                        ));
+                    <JSXElementName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXClosingFragment {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_closing_fragment`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_closing_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXClosingFragment {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_closing_fragment`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_closing_fragment(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXClosingFragment { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXClosingFragment(
+                            self,
+                            self::fields::JSXClosingFragmentField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXElement {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_element`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXElement {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_element`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXElement {
                 span,
@@ -62241,126 +37723,322 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXElement {
                 closing,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
+                        self,
+                        self::fields::JSXElementField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <JSXOpeningElement as VisitMutWith<V>>::visit_mut_with(opening, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
+                        self,
+                        self::fields::JSXElementField::Opening,
+                    ));
+                    <JSXOpeningElement as VisitWithAstPath<V>>::visit_with_ast_path(
+                        opening,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<JSXElementChild> as VisitMutWith<V>>::visit_mut_with(children, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
+                        self,
+                        self::fields::JSXElementField::Children(usize::MAX),
+                    ));
+                    <Vec<JSXElementChild> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<JSXClosingElement> as VisitMutWith<V>>::visit_mut_with(closing, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElement(
+                        self,
+                        self::fields::JSXElementField::Closing,
+                    ));
+                    <Option<JSXClosingElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        closing,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXElementChild {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_element_child`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_element_child(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXElementChild {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_element_child`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_child(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXElementChild::JSXText { 0: _field_0 } => {
-                <JSXText as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
+                    self,
+                    self::fields::JSXElementChildField::Jsxtext,
+                ));
+                <JSXText as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXExprContainer { 0: _field_0 } => {
-                <JSXExprContainer as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
+                    self,
+                    self::fields::JSXElementChildField::JsxexprContainer,
+                ));
+                <JSXExprContainer as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXSpreadChild { 0: _field_0 } => {
-                <JSXSpreadChild as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
+                    self,
+                    self::fields::JSXElementChildField::JsxspreadChild,
+                ));
+                <JSXSpreadChild as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
+                    self,
+                    self::fields::JSXElementChildField::Jsxelement,
+                ));
+                <Box<JSXElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementChild(
+                    self,
+                    self::fields::JSXElementChildField::Jsxfragment,
+                ));
+                <JSXFragment as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXElementName {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_element_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_element_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXElementName {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_element_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXElementName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementName(
+                    self,
+                    self::fields::JSXElementNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementName::JSXMemberExpr { 0: _field_0 } => {
-                <JSXMemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementName(
+                    self,
+                    self::fields::JSXElementNameField::JsxmemberExpr,
+                ));
+                <JSXMemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementName::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXElementName(
+                    self,
+                    self::fields::JSXElementNameField::JsxnamespacedName,
+                ));
+                <JSXNamespacedName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXEmptyExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_empty_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_empty_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXEmptyExpr {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_empty_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_empty_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXEmptyExpr { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXEmptyExpr(
+                        self,
+                        self::fields::JSXEmptyExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXExpr {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXExpr::JSXEmptyExpr { 0: _field_0 } => {
-                <JSXEmptyExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExpr(
+                    self,
+                    self::fields::JSXExprField::JsxemptyExpr,
+                ));
+                <JSXEmptyExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExpr(
+                    self,
+                    self::fields::JSXExprField::Expr,
+                ));
+                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXExprContainer {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_expr_container`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_expr_container(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXExprContainer {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_expr_container`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_expr_container(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXExprContainer { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExprContainer(
+                        self,
+                        self::fields::JSXExprContainerField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <JSXExpr as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXExprContainer(
+                        self,
+                        self::fields::JSXExprContainerField::Expr,
+                    ));
+                    <JSXExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXFragment {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_fragment`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXFragment {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_fragment`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_fragment(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXFragment {
                 span,
@@ -62369,89 +38047,228 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXFragment {
                 closing,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
+                        self,
+                        self::fields::JSXFragmentField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <JSXOpeningFragment as VisitMutWith<V>>::visit_mut_with(opening, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
+                        self,
+                        self::fields::JSXFragmentField::Opening,
+                    ));
+                    <JSXOpeningFragment as VisitWithAstPath<V>>::visit_with_ast_path(
+                        opening,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<JSXElementChild> as VisitMutWith<V>>::visit_mut_with(children, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
+                        self,
+                        self::fields::JSXFragmentField::Children(usize::MAX),
+                    ));
+                    <Vec<JSXElementChild> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <JSXClosingFragment as VisitMutWith<V>>::visit_mut_with(closing, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXFragment(
+                        self,
+                        self::fields::JSXFragmentField::Closing,
+                    ));
+                    <JSXClosingFragment as VisitWithAstPath<V>>::visit_with_ast_path(
+                        closing,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXMemberExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_member_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_member_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXMemberExpr {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_member_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_member_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXMemberExpr { span, obj, prop } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXMemberExpr(
+                        self,
+                        self::fields::JSXMemberExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <JSXObject as VisitMutWith<V>>::visit_mut_with(obj, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXMemberExpr(
+                        self,
+                        self::fields::JSXMemberExprField::Obj,
+                    ));
+                    <JSXObject as VisitWithAstPath<V>>::visit_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <IdentName as VisitMutWith<V>>::visit_mut_with(prop, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXMemberExpr(
+                        self,
+                        self::fields::JSXMemberExprField::Prop,
+                    ));
+                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXNamespacedName {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_namespaced_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_namespaced_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXNamespacedName {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_namespaced_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_namespaced_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXNamespacedName { span, ns, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXNamespacedName(
+                            self,
+                            self::fields::JSXNamespacedNameField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <IdentName as VisitMutWith<V>>::visit_mut_with(ns, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXNamespacedName(
+                            self,
+                            self::fields::JSXNamespacedNameField::Ns,
+                        ));
+                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ns,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <IdentName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXNamespacedName(
+                            self,
+                            self::fields::JSXNamespacedNameField::Name,
+                        ));
+                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXObject {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_object`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_object(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXObject {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_object`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_object(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXObject::JSXMemberExpr { 0: _field_0 } => {
-                <Box<JSXMemberExpr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXObject(
+                    self,
+                    self::fields::JSXObjectField::JsxmemberExpr,
+                ));
+                <Box<JSXMemberExpr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXObject::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXObject(
+                    self,
+                    self::fields::JSXObjectField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXOpeningElement {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_opening_element`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_opening_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXOpeningElement {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_opening_element`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_opening_element(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXOpeningElement {
                 name,
@@ -62461,270 +38278,653 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXOpeningElement {
                 type_args,
             } => {
                 {
-                    <JSXElementName as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
+                            self,
+                            self::fields::JSXOpeningElementField::Name,
+                        ));
+                    <JSXElementName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
+                            self,
+                            self::fields::JSXOpeningElementField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<JSXAttrOrSpread> as VisitMutWith<V>>::visit_mut_with(attrs, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
+                            self,
+                            self::fields::JSXOpeningElementField::Attrs(usize::MAX),
+                        ));
+                    <Vec<JSXAttrOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        attrs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
-                    )
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningElement(
+                            self,
+                            self::fields::JSXOpeningElementField::TypeArgs,
+                        ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXOpeningFragment {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_opening_fragment`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_opening_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXOpeningFragment {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_opening_fragment`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_opening_fragment(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXOpeningFragment { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::JSXOpeningFragment(
+                            self,
+                            self::fields::JSXOpeningFragmentField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXSpreadChild {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_spread_child`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_spread_child(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXSpreadChild {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_spread_child`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_spread_child(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXSpreadChild { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXSpreadChild(
+                        self,
+                        self::fields::JSXSpreadChildField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXSpreadChild(
+                        self,
+                        self::fields::JSXSpreadChildField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXText {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_text`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_text(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for JSXText {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_text`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_text(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             JSXText { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXText(
+                        self,
+                        self::fields::JSXTextField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXText(
+                        self,
+                        self::fields::JSXTextField::Value,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::JSXText(
+                        self,
+                        self::fields::JSXTextField::Raw,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Key {
-    #[doc = "Calls [VisitMut`::visit_mut_key`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_key(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Key {
+    #[doc = "Calls [VisitAstPath`::visit_key`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_key(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Key::Private { 0: _field_0 } => {
-                <PrivateName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Key(self, self::fields::KeyField::Private));
+                <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Key::Public { 0: _field_0 } => {
-                <PropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Key(self, self::fields::KeyField::Public));
+                <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyValuePatProp {
-    #[doc = "Calls [VisitMut`::visit_mut_key_value_pat_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_key_value_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyValuePatProp {
+    #[doc = "Calls [VisitAstPath`::visit_key_value_pat_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_key_value_pat_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             KeyValuePatProp { key, value } => {
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValuePatProp(
+                        self,
+                        self::fields::KeyValuePatPropField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValuePatProp(
+                        self,
+                        self::fields::KeyValuePatPropField::Value,
+                    ));
+                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyValueProp {
-    #[doc = "Calls [VisitMut`::visit_mut_key_value_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_key_value_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for KeyValueProp {
+    #[doc = "Calls [VisitAstPath`::visit_key_value_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_key_value_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             KeyValueProp { key, value } => {
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValueProp(
+                        self,
+                        self::fields::KeyValuePropField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::KeyValueProp(
+                        self,
+                        self::fields::KeyValuePropField::Value,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for LabeledStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_labeled_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_labeled_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for LabeledStmt {
+    #[doc = "Calls [VisitAstPath`::visit_labeled_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_labeled_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             LabeledStmt { span, label, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LabeledStmt(
+                        self,
+                        self::fields::LabeledStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(label, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LabeledStmt(
+                        self,
+                        self::fields::LabeledStmtField::Label,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::LabeledStmt(
+                        self,
+                        self::fields::LabeledStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Lit {
-    #[doc = "Calls [VisitMut`::visit_mut_lit`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Lit {
+    #[doc = "Calls [VisitAstPath`::visit_lit`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_lit(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Lit::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Str));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Bool { 0: _field_0 } => {
-                <Bool as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Bool));
+                <Bool as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Null { 0: _field_0 } => {
-                <Null as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Null));
+                <Null as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Num { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Num));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::BigInt { 0: _field_0 } => {
-                <BigInt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::BigInt));
+                <BigInt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Regex { 0: _field_0 } => {
-                <Regex as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Regex));
+                <Regex as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::JSXText { 0: _field_0 } => {
-                <JSXText as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Lit(self, self::fields::LitField::Jsxtext));
+                <JSXText as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MemberExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_member_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_member_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MemberExpr {
+    #[doc = "Calls [VisitAstPath`::visit_member_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_member_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MemberExpr { span, obj, prop } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberExpr(
+                        self,
+                        self::fields::MemberExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(obj, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberExpr(
+                        self,
+                        self::fields::MemberExprField::Obj,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MemberProp as VisitMutWith<V>>::visit_mut_with(prop, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberExpr(
+                        self,
+                        self::fields::MemberExprField::Prop,
+                    ));
+                    <MemberProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MemberProp {
-    #[doc = "Calls [VisitMut`::visit_mut_member_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_member_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MemberProp {
+    #[doc = "Calls [VisitAstPath`::visit_member_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_member_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MemberProp::Ident { 0: _field_0 } => {
-                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberProp(
+                    self,
+                    self::fields::MemberPropField::Ident,
+                ));
+                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MemberProp::PrivateName { 0: _field_0 } => {
-                <PrivateName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberProp(
+                    self,
+                    self::fields::MemberPropField::PrivateName,
+                ));
+                <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MemberProp::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MemberProp(
+                    self,
+                    self::fields::MemberPropField::Computed,
+                ));
+                <ComputedPropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MetaPropExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_meta_prop_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_meta_prop_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MetaPropExpr {
+    #[doc = "Calls [VisitAstPath`::visit_meta_prop_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_meta_prop_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MetaPropExpr { span, kind } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MetaPropExpr(
+                        self,
+                        self::fields::MetaPropExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MetaPropKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MetaPropExpr(
+                        self,
+                        self::fields::MetaPropExprField::Kind,
+                    ));
+                    <MetaPropKind as VisitWithAstPath<V>>::visit_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MetaPropKind {
-    #[doc = "Calls [VisitMut`::visit_mut_meta_prop_kind`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_meta_prop_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MetaPropKind {
+    #[doc = "Calls [VisitAstPath`::visit_meta_prop_kind`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_meta_prop_kind(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MetaPropKind::NewTarget => {}
             MetaPropKind::ImportMeta => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MethodKind {
-    #[doc = "Calls [VisitMut`::visit_mut_method_kind`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_method_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MethodKind {
+    #[doc = "Calls [VisitAstPath`::visit_method_kind`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_method_kind(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MethodKind::Method => {}
             MethodKind::Getter => {}
@@ -62732,32 +38932,68 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for MethodKind {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for MethodProp {
-    #[doc = "Calls [VisitMut`::visit_mut_method_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_method_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for MethodProp {
+    #[doc = "Calls [VisitAstPath`::visit_method_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_method_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             MethodProp { key, function } => {
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MethodProp(
+                        self,
+                        self::fields::MethodPropField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::MethodProp(
+                        self,
+                        self::fields::MethodPropField::Function,
+                    ));
+                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Module {
-    #[doc = "Calls [VisitMut`::visit_mut_module`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_module(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Module {
+    #[doc = "Calls [VisitAstPath`::visit_module`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Module {
                 span,
@@ -62765,97 +39001,265 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Module {
                 shebang,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Module(
+                        self,
+                        self::fields::ModuleField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ModuleItem> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Module(
+                        self,
+                        self::fields::ModuleField::Body(usize::MAX),
+                    ));
+                    <Vec<ModuleItem> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(shebang, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Module(
+                        self,
+                        self::fields::ModuleField::Shebang,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        shebang,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ModuleDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_module_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_module_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ModuleDecl {
+    #[doc = "Calls [VisitAstPath`::visit_module_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ModuleDecl::Import { 0: _field_0 } => {
-                <ImportDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::Import,
+                ));
+                <ImportDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportDecl { 0: _field_0 } => {
-                <ExportDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::ExportDecl,
+                ));
+                <ExportDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportNamed { 0: _field_0 } => {
-                <NamedExport as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::ExportNamed,
+                ));
+                <NamedExport as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportDefaultDecl { 0: _field_0 } => {
-                <ExportDefaultDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::ExportDefaultDecl,
+                ));
+                <ExportDefaultDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportDefaultExpr { 0: _field_0 } => {
-                <ExportDefaultExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::ExportDefaultExpr,
+                ));
+                <ExportDefaultExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportAll { 0: _field_0 } => {
-                <ExportAll as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::ExportAll,
+                ));
+                <ExportAll as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::TsImportEquals { 0: _field_0 } => {
-                <Box<TsImportEqualsDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::TsImportEquals,
+                ));
+                <Box<TsImportEqualsDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::TsExportAssignment { 0: _field_0 } => {
-                <TsExportAssignment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::TsExportAssignment,
+                ));
+                <TsExportAssignment as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::TsNamespaceExport { 0: _field_0 } => {
-                <TsNamespaceExportDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleDecl(
+                    self,
+                    self::fields::ModuleDeclField::TsNamespaceExport,
+                ));
+                <TsNamespaceExportDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ModuleExportName {
-    #[doc = "Calls [VisitMut`::visit_mut_module_export_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_module_export_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ModuleExportName {
+    #[doc = "Calls [VisitAstPath`::visit_module_export_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_export_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ModuleExportName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleExportName(
+                    self,
+                    self::fields::ModuleExportNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleExportName::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleExportName(
+                    self,
+                    self::fields::ModuleExportNameField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ModuleItem {
-    #[doc = "Calls [VisitMut`::visit_mut_module_item`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_module_item(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ModuleItem {
+    #[doc = "Calls [VisitAstPath`::visit_module_item`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_item(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ModuleItem::ModuleDecl { 0: _field_0 } => {
-                <ModuleDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleItem(
+                    self,
+                    self::fields::ModuleItemField::ModuleDecl,
+                ));
+                <ModuleDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleItem::Stmt { 0: _field_0 } => {
-                <Stmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ModuleItem(
+                    self,
+                    self::fields::ModuleItemField::Stmt,
+                ));
+                <Stmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamedExport {
-    #[doc = "Calls [VisitMut`::visit_mut_named_export`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_named_export(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NamedExport {
+    #[doc = "Calls [VisitAstPath`::visit_named_export`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_named_export(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NamedExport {
                 span,
@@ -62865,28 +39269,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamedExport {
                 with,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
+                        self,
+                        self::fields::NamedExportField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ExportSpecifier> as VisitMutWith<V>>::visit_mut_with(specifiers, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
+                        self,
+                        self::fields::NamedExportField::Specifiers(usize::MAX),
+                    ));
+                    <Vec<ExportSpecifier> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        specifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Str>> as VisitMutWith<V>>::visit_mut_with(src, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
+                        self,
+                        self::fields::NamedExportField::Src,
+                    ));
+                    <Option<Box<Str>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<ObjectLit>> as VisitMutWith<V>>::visit_mut_with(with, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NamedExport(
+                        self,
+                        self::fields::NamedExportField::With,
+                    ));
+                    <Option<Box<ObjectLit>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for NewExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_new_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_new_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for NewExpr {
+    #[doc = "Calls [VisitAstPath`::visit_new_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_new_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             NewExpr {
                 span,
@@ -62896,87 +39342,199 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for NewExpr {
                 type_args,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
+                        self,
+                        self::fields::NewExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
+                        self,
+                        self::fields::NewExprField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(callee, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
+                        self,
+                        self::fields::NewExprField::Callee,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Vec<ExprOrSpread>> as VisitMutWith<V>>::visit_mut_with(args, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
+                        self,
+                        self::fields::NewExprField::Args(usize::MAX),
+                    ));
+                    <Option<Vec<ExprOrSpread>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
-                    )
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::NewExpr(
+                        self,
+                        self::fields::NewExprField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Null {
-    #[doc = "Calls [VisitMut`::visit_mut_null`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_null(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Null {
+    #[doc = "Calls [VisitAstPath`::visit_null`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_null(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Null { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Null(self, self::fields::NullField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Number {
-    #[doc = "Calls [VisitMut`::visit_mut_number`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_number(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Number {
+    #[doc = "Calls [VisitAstPath`::visit_number`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_number(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Number { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
+                        self,
+                        self::fields::NumberField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Number(
+                        self,
+                        self::fields::NumberField::Raw,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ObjectLit {
-    #[doc = "Calls [VisitMut`::visit_mut_object_lit`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_object_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ObjectLit {
+    #[doc = "Calls [VisitAstPath`::visit_object_lit`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_lit(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ObjectLit { span, props } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectLit(
+                        self,
+                        self::fields::ObjectLitField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<PropOrSpread> as VisitMutWith<V>>::visit_mut_with(props, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectLit(
+                        self,
+                        self::fields::ObjectLitField::Props(usize::MAX),
+                    ));
+                    <Vec<PropOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        props,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ObjectPat {
-    #[doc = "Calls [VisitMut`::visit_mut_object_pat`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_object_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ObjectPat {
+    #[doc = "Calls [VisitAstPath`::visit_object_pat`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ObjectPat {
                 span,
@@ -62985,45 +39543,113 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for ObjectPat {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPat(
+                        self,
+                        self::fields::ObjectPatField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ObjectPatProp> as VisitMutWith<V>>::visit_mut_with(props, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPat(
+                        self,
+                        self::fields::ObjectPatField::Props(usize::MAX),
+                    ));
+                    <Vec<ObjectPatProp> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        props,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPat(
+                        self,
+                        self::fields::ObjectPatField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ObjectPatProp {
-    #[doc = "Calls [VisitMut`::visit_mut_object_pat_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_object_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ObjectPatProp {
+    #[doc = "Calls [VisitAstPath`::visit_object_pat_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ObjectPatProp::KeyValue { 0: _field_0 } => {
-                <KeyValuePatProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPatProp(
+                    self,
+                    self::fields::ObjectPatPropField::KeyValue,
+                ));
+                <KeyValuePatProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ObjectPatProp::Assign { 0: _field_0 } => {
-                <AssignPatProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPatProp(
+                    self,
+                    self::fields::ObjectPatPropField::Assign,
+                ));
+                <AssignPatProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ObjectPatProp::Rest { 0: _field_0 } => {
-                <RestPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ObjectPatProp(
+                    self,
+                    self::fields::ObjectPatPropField::Rest,
+                ));
+                <RestPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptCall {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_call`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_call(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptCall {
+    #[doc = "Calls [VisitAstPath`::visit_opt_call`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_call(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             OptCall {
                 span,
@@ -63033,50 +39659,120 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptCall {
                 type_args,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
+                        self,
+                        self::fields::OptCallField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
+                        self,
+                        self::fields::OptCallField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(callee, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
+                        self,
+                        self::fields::OptCallField::Callee,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(args, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
+                        self,
+                        self::fields::OptCallField::Args(usize::MAX),
+                    ));
+                    <Vec<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
-                    )
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptCall(
+                        self,
+                        self::fields::OptCallField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptChainBase {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_chain_base`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_chain_base(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptChainBase {
+    #[doc = "Calls [VisitAstPath`::visit_opt_chain_base`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_chain_base(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             OptChainBase::Member { 0: _field_0 } => {
-                <MemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainBase(
+                    self,
+                    self::fields::OptChainBaseField::Member,
+                ));
+                <MemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             OptChainBase::Call { 0: _field_0 } => {
-                <OptCall as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainBase(
+                    self,
+                    self::fields::OptChainBaseField::Call,
+                ));
+                <OptCall as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptChainExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_chain_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_chain_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for OptChainExpr {
+    #[doc = "Calls [VisitAstPath`::visit_opt_chain_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_chain_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             OptChainExpr {
                 span,
@@ -63084,22 +39780,48 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptChainExpr {
                 base,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainExpr(
+                        self,
+                        self::fields::OptChainExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<OptChainBase> as VisitMutWith<V>>::visit_mut_with(base, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::OptChainExpr(
+                        self,
+                        self::fields::OptChainExprField::Base,
+                    ));
+                    <Box<OptChainBase> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        base,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Param {
-    #[doc = "Calls [VisitMut`::visit_mut_param`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Param {
+    #[doc = "Calls [VisitAstPath`::visit_param`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_param(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Param {
                 span,
@@ -63107,93 +39829,229 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Param {
                 pat,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Param(
+                        self,
+                        self::fields::ParamField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Param(
+                        self,
+                        self::fields::ParamField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Pat as VisitMutWith<V>>::visit_mut_with(pat, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Param(self, self::fields::ParamField::Pat));
+                    <Pat as VisitWithAstPath<V>>::visit_with_ast_path(
+                        pat,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ParamOrTsParamProp {
-    #[doc = "Calls [VisitMut`::visit_mut_param_or_ts_param_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_param_or_ts_param_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ParamOrTsParamProp {
+    #[doc = "Calls [VisitAstPath`::visit_param_or_ts_param_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_param_or_ts_param_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ParamOrTsParamProp::TsParamProp { 0: _field_0 } => {
-                <TsParamProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParamOrTsParamProp(
+                    self,
+                    self::fields::ParamOrTsParamPropField::TsParamProp,
+                ));
+                <TsParamProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ParamOrTsParamProp::Param { 0: _field_0 } => {
-                <Param as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParamOrTsParamProp(
+                    self,
+                    self::fields::ParamOrTsParamPropField::Param,
+                ));
+                <Param as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ParenExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_paren_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_paren_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ParenExpr {
+    #[doc = "Calls [VisitAstPath`::visit_paren_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_paren_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ParenExpr { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParenExpr(
+                        self,
+                        self::fields::ParenExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ParenExpr(
+                        self,
+                        self::fields::ParenExprField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Pat {
-    #[doc = "Calls [VisitMut`::visit_mut_pat`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Pat {
+    #[doc = "Calls [VisitAstPath`::visit_pat`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pat(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Pat::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Ident));
+                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Array { 0: _field_0 } => {
-                <ArrayPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Array));
+                <ArrayPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Rest { 0: _field_0 } => {
-                <RestPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Rest));
+                <RestPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Object { 0: _field_0 } => {
-                <ObjectPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Object));
+                <ObjectPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Assign { 0: _field_0 } => {
-                <AssignPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Assign));
+                <AssignPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Invalid { 0: _field_0 } => {
-                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Invalid));
+                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Pat(self, self::fields::PatField::Expr));
+                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateMethod {
-    #[doc = "Calls [VisitMut`::visit_mut_private_method`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_private_method(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateMethod {
+    #[doc = "Calls [VisitAstPath`::visit_private_method`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_method(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PrivateMethod {
                 span,
@@ -63207,53 +40065,126 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateMethod {
                 is_override,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
+                        self,
+                        self::fields::PrivateMethodField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <PrivateName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
+                        self,
+                        self::fields::PrivateMethodField::Key,
+                    ));
+                    <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
+                        self,
+                        self::fields::PrivateMethodField::Function,
+                    ));
+                    <Box<Function> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <MethodKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
+                        self,
+                        self::fields::PrivateMethodField::Kind,
+                    ));
+                    <MethodKind as VisitWithAstPath<V>>::visit_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateMethod(
+                        self,
+                        self::fields::PrivateMethodField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
                         accessibility,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateName {
-    #[doc = "Calls [VisitMut`::visit_mut_private_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_private_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateName {
+    #[doc = "Calls [VisitAstPath`::visit_private_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PrivateName { span, name } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateName(
+                        self,
+                        self::fields::PrivateNameField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateName(
+                        self,
+                        self::fields::PrivateNameField::Name,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateProp {
-    #[doc = "Calls [VisitMut`::visit_mut_private_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_private_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PrivateProp {
+    #[doc = "Calls [VisitAstPath`::visit_private_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_private_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PrivateProp {
                 span,
@@ -63270,151 +40201,406 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateProp {
                 definite,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
+                        self,
+                        self::fields::PrivatePropField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
+                        self,
+                        self::fields::PrivatePropField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <PrivateName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
+                        self,
+                        self::fields::PrivatePropField::Key,
+                    ));
+                    <PrivateName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
+                        self,
+                        self::fields::PrivatePropField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
+                        self,
+                        self::fields::PrivatePropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
+                        self,
+                        self::fields::PrivatePropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PrivateProp(
+                        self,
+                        self::fields::PrivatePropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
                         accessibility,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Program {
-    #[doc = "Calls [VisitMut`::visit_mut_program`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_program(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Program {
+    #[doc = "Calls [VisitAstPath`::visit_program`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_program(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Program::Module { 0: _field_0 } => {
-                <Module as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Program(
+                    self,
+                    self::fields::ProgramField::Module,
+                ));
+                <Module as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Program::Script { 0: _field_0 } => {
-                <Script as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Program(
+                    self,
+                    self::fields::ProgramField::Script,
+                ));
+                <Script as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Prop {
-    #[doc = "Calls [VisitMut`::visit_mut_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Prop {
+    #[doc = "Calls [VisitAstPath`::visit_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Prop::Shorthand { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
+                    self,
+                    self::fields::PropField::Shorthand,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::KeyValue { 0: _field_0 } => {
-                <KeyValueProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
+                    self,
+                    self::fields::PropField::KeyValue,
+                ));
+                <KeyValueProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Assign { 0: _field_0 } => {
-                <AssignProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
+                    self,
+                    self::fields::PropField::Assign,
+                ));
+                <AssignProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Getter { 0: _field_0 } => {
-                <GetterProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
+                    self,
+                    self::fields::PropField::Getter,
+                ));
+                <GetterProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Setter { 0: _field_0 } => {
-                <SetterProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
+                    self,
+                    self::fields::PropField::Setter,
+                ));
+                <SetterProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Method { 0: _field_0 } => {
-                <MethodProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Prop(
+                    self,
+                    self::fields::PropField::Method,
+                ));
+                <MethodProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PropName {
-    #[doc = "Calls [VisitMut`::visit_mut_prop_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_prop_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PropName {
+    #[doc = "Calls [VisitAstPath`::visit_prop_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PropName::Ident { 0: _field_0 } => {
-                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
+                    self,
+                    self::fields::PropNameField::Ident,
+                ));
+                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
+                    self,
+                    self::fields::PropNameField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::Num { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
+                    self,
+                    self::fields::PropNameField::Num,
+                ));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
+                    self,
+                    self::fields::PropNameField::Computed,
+                ));
+                <ComputedPropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::BigInt { 0: _field_0 } => {
-                <BigInt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropName(
+                    self,
+                    self::fields::PropNameField::BigInt,
+                ));
+                <BigInt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for PropOrSpread {
-    #[doc = "Calls [VisitMut`::visit_mut_prop_or_spread`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_prop_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for PropOrSpread {
+    #[doc = "Calls [VisitAstPath`::visit_prop_or_spread`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_or_spread(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             PropOrSpread::Spread { 0: _field_0 } => {
-                <SpreadElement as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropOrSpread(
+                    self,
+                    self::fields::PropOrSpreadField::Spread,
+                ));
+                <SpreadElement as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropOrSpread::Prop { 0: _field_0 } => {
-                <Box<Prop> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::PropOrSpread(
+                    self,
+                    self::fields::PropOrSpreadField::Prop,
+                ));
+                <Box<Prop> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Regex {
-    #[doc = "Calls [VisitMut`::visit_mut_regex`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_regex(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Regex {
+    #[doc = "Calls [VisitAstPath`::visit_regex`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_regex(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Regex { span, exp, flags } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Regex(
+                        self,
+                        self::fields::RegexField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(exp, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Regex(self, self::fields::RegexField::Exp));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        exp,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(flags, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Regex(
+                        self,
+                        self::fields::RegexField::Flags,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        flags,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for RestPat {
-    #[doc = "Calls [VisitMut`::visit_mut_rest_pat`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_rest_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for RestPat {
+    #[doc = "Calls [VisitAstPath`::visit_rest_pat`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_rest_pat(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             RestPat {
                 span,
@@ -63423,47 +40609,115 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for RestPat {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
+                        self,
+                        self::fields::RestPatField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(dot3_token, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
+                        self,
+                        self::fields::RestPatField::Dot3Token,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        dot3_token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
+                        self,
+                        self::fields::RestPatField::Arg,
+                    ));
+                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::RestPat(
+                        self,
+                        self::fields::RestPatField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ReturnStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_return_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_return_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ReturnStmt {
+    #[doc = "Calls [VisitAstPath`::visit_return_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_return_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ReturnStmt { span, arg } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ReturnStmt(
+                        self,
+                        self::fields::ReturnStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ReturnStmt(
+                        self,
+                        self::fields::ReturnStmtField::Arg,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Script {
-    #[doc = "Calls [VisitMut`::visit_mut_script`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_script(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Script {
+    #[doc = "Calls [VisitAstPath`::visit_script`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_script(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Script {
                 span,
@@ -63471,44 +40725,104 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Script {
                 shebang,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Script(
+                        self,
+                        self::fields::ScriptField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Script(
+                        self,
+                        self::fields::ScriptField::Body(usize::MAX),
+                    ));
+                    <Vec<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(shebang, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Script(
+                        self,
+                        self::fields::ScriptField::Shebang,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        shebang,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SeqExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_seq_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_seq_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SeqExpr {
+    #[doc = "Calls [VisitAstPath`::visit_seq_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_seq_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SeqExpr { span, exprs } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SeqExpr(
+                        self,
+                        self::fields::SeqExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(exprs, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SeqExpr(
+                        self,
+                        self::fields::SeqExprField::Exprs(usize::MAX),
+                    ));
+                    <Vec<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        exprs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SetterProp {
-    #[doc = "Calls [VisitMut`::visit_mut_setter_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_setter_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SetterProp {
+    #[doc = "Calls [VisitAstPath`::visit_setter_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_setter_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SetterProp {
                 span,
@@ -63518,280 +40832,756 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SetterProp {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
+                        self,
+                        self::fields::SetterPropField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
+                        self,
+                        self::fields::SetterPropField::Key,
+                    ));
+                    <PropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Pat> as VisitMutWith<V>>::visit_mut_with(this_param, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
+                        self,
+                        self::fields::SetterPropField::ThisParam,
+                    ));
+                    <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        this_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(param, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
+                        self,
+                        self::fields::SetterPropField::Param,
+                    ));
+                    <Box<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SetterProp(
+                        self,
+                        self::fields::SetterPropField::Body,
+                    ));
+                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SimpleAssignTarget {
-    #[doc = "Calls [VisitMut`::visit_mut_simple_assign_target`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_simple_assign_target(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SimpleAssignTarget {
+    #[doc = "Calls [VisitAstPath`::visit_simple_assign_target`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_simple_assign_target(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SimpleAssignTarget::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::Ident,
+                ));
+                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::Member { 0: _field_0 } => {
-                <MemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::Member,
+                ));
+                <MemberExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::SuperProp { 0: _field_0 } => {
-                <SuperPropExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::SuperProp,
+                ));
+                <SuperPropExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::Paren { 0: _field_0 } => {
-                <ParenExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::Paren,
+                ));
+                <ParenExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::OptChain { 0: _field_0 } => {
-                <OptChainExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::OptChain,
+                ));
+                <OptChainExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsAs { 0: _field_0 } => {
-                <TsAsExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::TsAs,
+                ));
+                <TsAsExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsSatisfies { 0: _field_0 } => {
-                <TsSatisfiesExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::TsSatisfies,
+                ));
+                <TsSatisfiesExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsNonNull { 0: _field_0 } => {
-                <TsNonNullExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::TsNonNull,
+                ));
+                <TsNonNullExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsTypeAssertion { 0: _field_0 } => {
-                <TsTypeAssertion as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::TsTypeAssertion,
+                ));
+                <TsTypeAssertion as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsInstantiation { 0: _field_0 } => {
-                <TsInstantiation as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::TsInstantiation,
+                ));
+                <TsInstantiation as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::Invalid { 0: _field_0 } => {
-                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SimpleAssignTarget(
+                    self,
+                    self::fields::SimpleAssignTargetField::Invalid,
+                ));
+                <Invalid as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SpreadElement {
-    #[doc = "Calls [VisitMut`::visit_mut_spread_element`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_spread_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SpreadElement {
+    #[doc = "Calls [VisitAstPath`::visit_spread_element`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_spread_element(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SpreadElement { dot3_token, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(dot3_token, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SpreadElement(
+                        self,
+                        self::fields::SpreadElementField::Dot3Token,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        dot3_token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SpreadElement(
+                        self,
+                        self::fields::SpreadElementField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for StaticBlock {
-    #[doc = "Calls [VisitMut`::visit_mut_static_block`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_static_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for StaticBlock {
+    #[doc = "Calls [VisitAstPath`::visit_static_block`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_static_block(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             StaticBlock { span, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StaticBlock(
+                        self,
+                        self::fields::StaticBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <BlockStmt as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::StaticBlock(
+                        self,
+                        self::fields::StaticBlockField::Body,
+                    ));
+                    <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Stmt {
-    #[doc = "Calls [VisitMut`::visit_mut_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Stmt {
+    #[doc = "Calls [VisitAstPath`::visit_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Stmt::Block { 0: _field_0 } => {
-                <BlockStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Block));
+                <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Empty { 0: _field_0 } => {
-                <EmptyStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Empty));
+                <EmptyStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Debugger { 0: _field_0 } => {
-                <DebuggerStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
+                    self,
+                    self::fields::StmtField::Debugger,
+                ));
+                <DebuggerStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::With { 0: _field_0 } => {
-                <WithStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::With));
+                <WithStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Return { 0: _field_0 } => {
-                <ReturnStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
+                    self,
+                    self::fields::StmtField::Return,
+                ));
+                <ReturnStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Labeled { 0: _field_0 } => {
-                <LabeledStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
+                    self,
+                    self::fields::StmtField::Labeled,
+                ));
+                <LabeledStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Break { 0: _field_0 } => {
-                <BreakStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Break));
+                <BreakStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Continue { 0: _field_0 } => {
-                <ContinueStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
+                    self,
+                    self::fields::StmtField::Continue,
+                ));
+                <ContinueStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::If { 0: _field_0 } => {
-                <IfStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::If));
+                <IfStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Switch { 0: _field_0 } => {
-                <SwitchStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
+                    self,
+                    self::fields::StmtField::Switch,
+                ));
+                <SwitchStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Throw { 0: _field_0 } => {
-                <ThrowStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Throw));
+                <ThrowStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Try { 0: _field_0 } => {
-                <Box<TryStmt> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Try));
+                <Box<TryStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::While { 0: _field_0 } => {
-                <WhileStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::While));
+                <WhileStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::DoWhile { 0: _field_0 } => {
-                <DoWhileStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Stmt(
+                    self,
+                    self::fields::StmtField::DoWhile,
+                ));
+                <DoWhileStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::For { 0: _field_0 } => {
-                <ForStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::For));
+                <ForStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::ForIn { 0: _field_0 } => {
-                <ForInStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::ForIn));
+                <ForInStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::ForOf { 0: _field_0 } => {
-                <ForOfStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::ForOf));
+                <ForOfStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Decl { 0: _field_0 } => {
-                <Decl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Decl));
+                <Decl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Expr { 0: _field_0 } => {
-                <ExprStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::Stmt(self, self::fields::StmtField::Expr));
+                <ExprStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Str {
-    #[doc = "Calls [VisitMut`::visit_mut_str`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_str(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Str {
+    #[doc = "Calls [VisitAstPath`::visit_str`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_str(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Str { span, value, raw } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Value));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Str(self, self::fields::StrField::Raw));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Super {
-    #[doc = "Calls [VisitMut`::visit_mut_super`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_super(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Super {
+    #[doc = "Calls [VisitAstPath`::visit_super`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_super(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Super { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Super(
+                        self,
+                        self::fields::SuperField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SuperProp {
-    #[doc = "Calls [VisitMut`::visit_mut_super_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_super_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SuperProp {
+    #[doc = "Calls [VisitAstPath`::visit_super_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_super_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SuperProp::Ident { 0: _field_0 } => {
-                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperProp(
+                    self,
+                    self::fields::SuperPropField::Ident,
+                ));
+                <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SuperProp::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperProp(
+                    self,
+                    self::fields::SuperPropField::Computed,
+                ));
+                <ComputedPropName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SuperPropExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_super_prop_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_super_prop_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SuperPropExpr {
+    #[doc = "Calls [VisitAstPath`::visit_super_prop_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_super_prop_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SuperPropExpr { span, obj, prop } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperPropExpr(
+                        self,
+                        self::fields::SuperPropExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Super as VisitMutWith<V>>::visit_mut_with(obj, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperPropExpr(
+                        self,
+                        self::fields::SuperPropExprField::Obj,
+                    ));
+                    <Super as VisitWithAstPath<V>>::visit_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <SuperProp as VisitMutWith<V>>::visit_mut_with(prop, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SuperPropExpr(
+                        self,
+                        self::fields::SuperPropExprField::Prop,
+                    ));
+                    <SuperProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SwitchCase {
-    #[doc = "Calls [VisitMut`::visit_mut_switch_case`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_switch_case(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SwitchCase {
+    #[doc = "Calls [VisitAstPath`::visit_switch_case`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_case(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SwitchCase { span, test, cons } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchCase(
+                        self,
+                        self::fields::SwitchCaseField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(test, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchCase(
+                        self,
+                        self::fields::SwitchCaseField::Test,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Stmt> as VisitMutWith<V>>::visit_mut_with(cons, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchCase(
+                        self,
+                        self::fields::SwitchCaseField::Cons(usize::MAX),
+                    ));
+                    <Vec<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for SwitchStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_switch_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_switch_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for SwitchStmt {
+    #[doc = "Calls [VisitAstPath`::visit_switch_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             SwitchStmt {
                 span,
@@ -63799,25 +41589,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for SwitchStmt {
                 cases,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchStmt(
+                        self,
+                        self::fields::SwitchStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(discriminant, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchStmt(
+                        self,
+                        self::fields::SwitchStmtField::Discriminant,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        discriminant,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<SwitchCase> as VisitMutWith<V>>::visit_mut_with(cases, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::SwitchStmt(
+                        self,
+                        self::fields::SwitchStmtField::Cases(usize::MAX),
+                    ));
+                    <Vec<SwitchCase> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        cases,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TaggedTpl {
-    #[doc = "Calls [VisitMut`::visit_mut_tagged_tpl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_tagged_tpl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TaggedTpl {
+    #[doc = "Calls [VisitAstPath`::visit_tagged_tpl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tagged_tpl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TaggedTpl {
                 span,
@@ -63827,69 +41651,156 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TaggedTpl {
                 tpl,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
+                        self,
+                        self::fields::TaggedTplField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(tag, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
+                        self,
+                        self::fields::TaggedTplField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_params,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
+                        self,
+                        self::fields::TaggedTplField::Tag,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        tag,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<Tpl> as VisitMutWith<V>>::visit_mut_with(tpl, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
+                        self,
+                        self::fields::TaggedTplField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TaggedTpl(
+                        self,
+                        self::fields::TaggedTplField::Tpl,
+                    ));
+                    <Box<Tpl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        tpl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ThisExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_this_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_this_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ThisExpr {
+    #[doc = "Calls [VisitAstPath`::visit_this_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_this_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ThisExpr { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ThisExpr(
+                        self,
+                        self::fields::ThisExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for ThrowStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_throw_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_throw_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for ThrowStmt {
+    #[doc = "Calls [VisitAstPath`::visit_throw_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_throw_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             ThrowStmt { span, arg } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ThrowStmt(
+                        self,
+                        self::fields::ThrowStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::ThrowStmt(
+                        self,
+                        self::fields::ThrowStmtField::Arg,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Tpl {
-    #[doc = "Calls [VisitMut`::visit_mut_tpl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_tpl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Tpl {
+    #[doc = "Calls [VisitAstPath`::visit_tpl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tpl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Tpl {
                 span,
@@ -63897,25 +41808,57 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Tpl {
                 quasis,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentNodeRef::Tpl(self, self::fields::TplField::Span));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(exprs, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Tpl(
+                        self,
+                        self::fields::TplField::Exprs(usize::MAX),
+                    ));
+                    <Vec<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        exprs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TplElement> as VisitMutWith<V>>::visit_mut_with(quasis, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::Tpl(
+                        self,
+                        self::fields::TplField::Quasis(usize::MAX),
+                    ));
+                    <Vec<TplElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        quasis,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TplElement {
-    #[doc = "Calls [VisitMut`::visit_mut_tpl_element`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_tpl_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TplElement {
+    #[doc = "Calls [VisitAstPath`::visit_tpl_element`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tpl_element(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TplElement {
                 span,
@@ -63924,25 +41867,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TplElement {
                 raw,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TplElement(
+                        self,
+                        self::fields::TplElementField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(cooked, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TplElement(
+                        self,
+                        self::fields::TplElementField::Cooked,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        cooked,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TplElement(
+                        self,
+                        self::fields::TplElementField::Raw,
+                    ));
+                    <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TruePlusMinus {
-    #[doc = "Calls [VisitMut`::visit_mut_true_plus_minus`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_true_plus_minus(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TruePlusMinus {
+    #[doc = "Calls [VisitAstPath`::visit_true_plus_minus`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_true_plus_minus(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TruePlusMinus::True => {}
             TruePlusMinus::Plus => {}
@@ -63950,13 +41927,23 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TruePlusMinus {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TryStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_try_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_try_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TryStmt {
+    #[doc = "Calls [VisitAstPath`::visit_try_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_try_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TryStmt {
                 span,
@@ -63965,47 +41952,115 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TryStmt {
                 finalizer,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
+                        self,
+                        self::fields::TryStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <BlockStmt as VisitMutWith<V>>::visit_mut_with(block, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
+                        self,
+                        self::fields::TryStmtField::Block,
+                    ));
+                    <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<CatchClause> as VisitMutWith<V>>::visit_mut_with(handler, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
+                        self,
+                        self::fields::TryStmtField::Handler,
+                    ));
+                    <Option<CatchClause> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        handler,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(finalizer, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TryStmt(
+                        self,
+                        self::fields::TryStmtField::Finalizer,
+                    ));
+                    <Option<BlockStmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        finalizer,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsArrayType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_array_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_array_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsArrayType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_array_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_array_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsArrayType { span, elem_type } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsArrayType(
+                        self,
+                        self::fields::TsArrayTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(elem_type, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsArrayType(
+                        self,
+                        self::fields::TsArrayTypeField::ElemType,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        elem_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsAsExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_as_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_as_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsAsExpr {
+    #[doc = "Calls [VisitAstPath`::visit_ts_as_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_as_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsAsExpr {
                 span,
@@ -64013,25 +42068,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsAsExpr {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsAsExpr(
+                        self,
+                        self::fields::TsAsExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsAsExpr(
+                        self,
+                        self::fields::TsAsExprField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsAsExpr(
+                        self,
+                        self::fields::TsAsExprField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsCallSignatureDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_call_signature_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_call_signature_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsCallSignatureDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_call_signature_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_call_signature_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsCallSignatureDecl {
                 span,
@@ -64040,31 +42129,74 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsCallSignatureDecl {
                 type_params,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
+                            self,
+                            self::fields::TsCallSignatureDeclField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
+                            self,
+                            self::fields::TsCallSignatureDeclField::Params(usize::MAX),
+                        ));
+                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
+                            self,
+                            self::fields::TsCallSignatureDeclField::TypeAnn,
+                        ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsCallSignatureDecl(
+                            self,
+                            self::fields::TsCallSignatureDeclField::TypeParams,
+                        ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConditionalType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_conditional_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_conditional_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConditionalType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_conditional_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_conditional_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsConditionalType {
                 span,
@@ -64074,50 +42206,131 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConditionalType {
                 false_type,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
+                            self,
+                            self::fields::TsConditionalTypeField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(check_type, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
+                            self,
+                            self::fields::TsConditionalTypeField::CheckType,
+                        ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        check_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(extends_type, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
+                            self,
+                            self::fields::TsConditionalTypeField::ExtendsType,
+                        ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        extends_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(true_type, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
+                            self,
+                            self::fields::TsConditionalTypeField::TrueType,
+                        ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        true_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(false_type, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConditionalType(
+                            self,
+                            self::fields::TsConditionalTypeField::FalseType,
+                        ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        false_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstAssertion {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_const_assertion`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_const_assertion(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstAssertion {
+    #[doc = "Calls [VisitAstPath`::visit_ts_const_assertion`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_const_assertion(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsConstAssertion { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsConstAssertion(
+                        self,
+                        self::fields::TsConstAssertionField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsConstAssertion(
+                        self,
+                        self::fields::TsConstAssertionField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstructSignatureDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_construct_signature_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_construct_signature_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstructSignatureDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_construct_signature_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_construct_signature_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsConstructSignatureDecl {
                 span,
@@ -64126,31 +42339,74 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstructSignatureDecl {
                 type_params,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
+                            self,
+                            self::fields::TsConstructSignatureDeclField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
+                            self,
+                            self::fields::TsConstructSignatureDeclField::Params(usize::MAX),
+                        ));
+                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
+                            self,
+                            self::fields::TsConstructSignatureDeclField::TypeAnn,
+                        ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructSignatureDecl(
+                            self,
+                            self::fields::TsConstructSignatureDeclField::TypeParams,
+                        ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstructorType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_constructor_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_constructor_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsConstructorType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_constructor_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_constructor_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsConstructorType {
                 span,
@@ -64160,48 +42416,117 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstructorType {
                 is_abstract,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
+                            self,
+                            self::fields::TsConstructorTypeField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
+                            self,
+                            self::fields::TsConstructorTypeField::Params(usize::MAX),
+                        ));
+                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
+                            self,
+                            self::fields::TsConstructorTypeField::TypeParams,
+                        ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<TsTypeAnn> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsConstructorType(
+                            self,
+                            self::fields::TsConstructorTypeField::TypeAnn,
+                        ));
+                    <Box<TsTypeAnn> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEntityName {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_entity_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_entity_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEntityName {
+    #[doc = "Calls [VisitAstPath`::visit_ts_entity_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_entity_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsEntityName::TsQualifiedName { 0: _field_0 } => {
-                <Box<TsQualifiedName> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEntityName(
+                    self,
+                    self::fields::TsEntityNameField::TsQualifiedName,
+                ));
+                <Box<TsQualifiedName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsEntityName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEntityName(
+                    self,
+                    self::fields::TsEntityNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEnumDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_enum_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEnumDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_enum_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsEnumDecl {
                 span,
@@ -64211,83 +42536,205 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEnumDecl {
                 members,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumDecl(
+                        self,
+                        self::fields::TsEnumDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumDecl(
+                        self,
+                        self::fields::TsEnumDeclField::Id,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsEnumMember> as VisitMutWith<V>>::visit_mut_with(members, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumDecl(
+                        self,
+                        self::fields::TsEnumDeclField::Members(usize::MAX),
+                    ));
+                    <Vec<TsEnumMember> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        members,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEnumMember {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_member`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_enum_member(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEnumMember {
+    #[doc = "Calls [VisitAstPath`::visit_ts_enum_member`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_member(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsEnumMember { span, id, init } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMember(
+                        self,
+                        self::fields::TsEnumMemberField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsEnumMemberId as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMember(
+                        self,
+                        self::fields::TsEnumMemberField::Id,
+                    ));
+                    <TsEnumMemberId as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(init, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMember(
+                        self,
+                        self::fields::TsEnumMemberField::Init,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEnumMemberId {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_member_id`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_enum_member_id(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsEnumMemberId {
+    #[doc = "Calls [VisitAstPath`::visit_ts_enum_member_id`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_member_id(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsEnumMemberId::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMemberId(
+                    self,
+                    self::fields::TsEnumMemberIdField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsEnumMemberId::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsEnumMemberId(
+                    self,
+                    self::fields::TsEnumMemberIdField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsExportAssignment {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_export_assignment`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_export_assignment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsExportAssignment {
+    #[doc = "Calls [VisitAstPath`::visit_ts_export_assignment`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_export_assignment(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsExportAssignment { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsExportAssignment(
+                            self,
+                            self::fields::TsExportAssignmentField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsExportAssignment(
+                            self,
+                            self::fields::TsExportAssignmentField::Expr,
+                        ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsExprWithTypeArgs {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_expr_with_type_args`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_expr_with_type_args(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsExprWithTypeArgs {
+    #[doc = "Calls [VisitAstPath`::visit_ts_expr_with_type_args`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_expr_with_type_args(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsExprWithTypeArgs {
                 span,
@@ -64295,86 +42742,215 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsExprWithTypeArgs {
                 type_args,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsExprWithTypeArgs(
+                            self,
+                            self::fields::TsExprWithTypeArgsField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsExprWithTypeArgs(
+                            self,
+                            self::fields::TsExprWithTypeArgsField::Expr,
+                        ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
-                    )
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsExprWithTypeArgs(
+                            self,
+                            self::fields::TsExprWithTypeArgsField::TypeArgs,
+                        ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsExternalModuleRef {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_external_module_ref`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_external_module_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsExternalModuleRef {
+    #[doc = "Calls [VisitAstPath`::visit_ts_external_module_ref`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_external_module_ref(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsExternalModuleRef { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsExternalModuleRef(
+                            self,
+                            self::fields::TsExternalModuleRefField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Str as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsExternalModuleRef(
+                            self,
+                            self::fields::TsExternalModuleRefField::Expr,
+                        ));
+                    <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsFnOrConstructorType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_or_constructor_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsFnOrConstructorType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_fn_or_constructor_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_or_constructor_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsFnOrConstructorType::TsFnType { 0: _field_0 } => {
-                <TsFnType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::TsFnOrConstructorType(
+                        self,
+                        self::fields::TsFnOrConstructorTypeField::TsFnType,
+                    ));
+                <TsFnType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnOrConstructorType::TsConstructorType { 0: _field_0 } => {
-                <TsConstructorType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::TsFnOrConstructorType(
+                        self,
+                        self::fields::TsFnOrConstructorTypeField::TsConstructorType,
+                    ));
+                <TsConstructorType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsFnParam {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_param`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_fn_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsFnParam {
+    #[doc = "Calls [VisitAstPath`::visit_ts_fn_param`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_param(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsFnParam::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
+                    self,
+                    self::fields::TsFnParamField::Ident,
+                ));
+                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnParam::Array { 0: _field_0 } => {
-                <ArrayPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
+                    self,
+                    self::fields::TsFnParamField::Array,
+                ));
+                <ArrayPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnParam::Rest { 0: _field_0 } => {
-                <RestPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
+                    self,
+                    self::fields::TsFnParamField::Rest,
+                ));
+                <RestPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnParam::Object { 0: _field_0 } => {
-                <ObjectPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnParam(
+                    self,
+                    self::fields::TsFnParamField::Object,
+                ));
+                <ObjectPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsFnType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_fn_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsFnType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_fn_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsFnType {
                 span,
@@ -64383,31 +42959,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsFnType {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
+                        self,
+                        self::fields::TsFnTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
+                        self,
+                        self::fields::TsFnTypeField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
+                        self,
+                        self::fields::TsFnTypeField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<TsTypeAnn> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsFnType(
+                        self,
+                        self::fields::TsFnTypeField::TypeAnn,
+                    ));
+                    <Box<TsTypeAnn> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsGetterSignature {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_getter_signature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_getter_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsGetterSignature {
+    #[doc = "Calls [VisitAstPath`::visit_ts_getter_signature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_getter_signature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsGetterSignature {
                 span,
@@ -64416,25 +43031,62 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsGetterSignature {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsGetterSignature(
+                            self,
+                            self::fields::TsGetterSignatureField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsGetterSignature(
+                            self,
+                            self::fields::TsGetterSignatureField::Key,
+                        ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsGetterSignature(
+                            self,
+                            self::fields::TsGetterSignatureField::TypeAnn,
+                        ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsImportEqualsDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_import_equals_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_import_equals_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsImportEqualsDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_import_equals_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_import_equals_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsImportEqualsDecl {
                 span,
@@ -64444,25 +43096,62 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsImportEqualsDecl {
                 module_ref,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsImportEqualsDecl(
+                            self,
+                            self::fields::TsImportEqualsDeclField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsImportEqualsDecl(
+                            self,
+                            self::fields::TsImportEqualsDeclField::Id,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsModuleRef as VisitMutWith<V>>::visit_mut_with(module_ref, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsImportEqualsDecl(
+                            self,
+                            self::fields::TsImportEqualsDeclField::ModuleRef,
+                        ));
+                    <TsModuleRef as VisitWithAstPath<V>>::visit_with_ast_path(
+                        module_ref,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsImportType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_import_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_import_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsImportType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_import_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_import_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsImportType {
                 span,
@@ -64471,30 +43160,66 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsImportType {
                 type_args,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
+                        self,
+                        self::fields::TsImportTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Str as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
+                        self,
+                        self::fields::TsImportTypeField::Arg,
+                    ));
+                    <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<TsEntityName> as VisitMutWith<V>>::visit_mut_with(qualifier, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
+                        self,
+                        self::fields::TsImportTypeField::Qualifier,
+                    ));
+                    <Option<TsEntityName> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        qualifier,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
-                    )
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsImportType(
+                        self,
+                        self::fields::TsImportTypeField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIndexSignature {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_index_signature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_index_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIndexSignature {
+    #[doc = "Calls [VisitAstPath`::visit_ts_index_signature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_index_signature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsIndexSignature {
                 params,
@@ -64504,25 +43229,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIndexSignature {
                 span,
             } => {
                 {
-                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsIndexSignature(
+                        self,
+                        self::fields::TsIndexSignatureField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsIndexSignature(
+                        self,
+                        self::fields::TsIndexSignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsIndexSignature(
+                        self,
+                        self::fields::TsIndexSignatureField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIndexedAccessType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_indexed_access_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_indexed_access_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIndexedAccessType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_indexed_access_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_indexed_access_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsIndexedAccessType {
                 span,
@@ -64531,44 +43290,107 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIndexedAccessType {
                 index_type,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsIndexedAccessType(
+                            self,
+                            self::fields::TsIndexedAccessTypeField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(obj_type, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsIndexedAccessType(
+                            self,
+                            self::fields::TsIndexedAccessTypeField::ObjType,
+                        ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        obj_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(index_type, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsIndexedAccessType(
+                            self,
+                            self::fields::TsIndexedAccessTypeField::IndexType,
+                        ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        index_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInferType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_infer_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_infer_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInferType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_infer_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_infer_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsInferType { span, type_param } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInferType(
+                        self,
+                        self::fields::TsInferTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsTypeParam as VisitMutWith<V>>::visit_mut_with(type_param, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInferType(
+                        self,
+                        self::fields::TsInferTypeField::TypeParam,
+                    ));
+                    <TsTypeParam as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInstantiation {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_instantiation`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_instantiation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInstantiation {
+    #[doc = "Calls [VisitAstPath`::visit_ts_instantiation`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_instantiation(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsInstantiation {
                 span,
@@ -64576,46 +43398,104 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInstantiation {
                 type_args,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInstantiation(
+                        self,
+                        self::fields::TsInstantiationField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInstantiation(
+                        self,
+                        self::fields::TsInstantiationField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsTypeParamInstantiation> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInstantiation(
+                        self,
+                        self::fields::TsInstantiationField::TypeArgs,
+                    ));
+                    <Box<TsTypeParamInstantiation> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_args,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInterfaceBody {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_interface_body`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_interface_body(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInterfaceBody {
+    #[doc = "Calls [VisitAstPath`::visit_ts_interface_body`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_interface_body(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsInterfaceBody { span, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceBody(
+                        self,
+                        self::fields::TsInterfaceBodyField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsTypeElement> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceBody(
+                        self,
+                        self::fields::TsInterfaceBodyField::Body(usize::MAX),
+                    ));
+                    <Vec<TsTypeElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInterfaceDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_interface_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_interface_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsInterfaceDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_interface_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_interface_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsInterfaceDecl {
                 span,
@@ -64626,72 +43506,173 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInterfaceDecl {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
+                        self,
+                        self::fields::TsInterfaceDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
+                        self,
+                        self::fields::TsInterfaceDeclField::Id,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
+                        self,
+                        self::fields::TsInterfaceDeclField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Vec<TsExprWithTypeArgs> as VisitMutWith<V>>::visit_mut_with(extends, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
+                        self,
+                        self::fields::TsInterfaceDeclField::Extends(usize::MAX),
+                    ));
+                    <Vec<TsExprWithTypeArgs> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        extends,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsInterfaceBody as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsInterfaceDecl(
+                        self,
+                        self::fields::TsInterfaceDeclField::Body,
+                    ));
+                    <TsInterfaceBody as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIntersectionType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_intersection_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_intersection_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsIntersectionType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_intersection_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_intersection_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsIntersectionType { span, types } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsIntersectionType(
+                            self,
+                            self::fields::TsIntersectionTypeField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(types, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsIntersectionType(
+                            self,
+                            self::fields::TsIntersectionTypeField::Types(usize::MAX),
+                        ));
+                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsKeywordType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_keyword_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_keyword_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsKeywordType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_keyword_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_keyword_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsKeywordType { span, kind } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsKeywordType(
+                        self,
+                        self::fields::TsKeywordTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsKeywordTypeKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsKeywordType(
+                        self,
+                        self::fields::TsKeywordTypeField::Kind,
+                    ));
+                    <TsKeywordTypeKind as VisitWithAstPath<V>>::visit_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsKeywordTypeKind {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_keyword_type_kind`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_keyword_type_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsKeywordTypeKind {
+    #[doc = "Calls [VisitAstPath`::visit_ts_keyword_type_kind`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_keyword_type_kind(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsKeywordTypeKind::TsAnyKeyword => {}
             TsKeywordTypeKind::TsUnknownKeyword => {}
@@ -64709,58 +43690,140 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsKeywordTypeKind {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsLit {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_lit`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsLit {
+    #[doc = "Calls [VisitAstPath`::visit_ts_lit`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_lit(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsLit::Number { 0: _field_0 } => {
-                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLit(
+                    self,
+                    self::fields::TsLitField::Number,
+                ));
+                <Number as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::TsLit(self, self::fields::TsLitField::Str));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::Bool { 0: _field_0 } => {
-                <Bool as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLit(
+                    self,
+                    self::fields::TsLitField::Bool,
+                ));
+                <Bool as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::BigInt { 0: _field_0 } => {
-                <BigInt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLit(
+                    self,
+                    self::fields::TsLitField::BigInt,
+                ));
+                <BigInt as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::Tpl { 0: _field_0 } => {
-                <TsTplLitType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentNodeRef::TsLit(self, self::fields::TsLitField::Tpl));
+                <TsTplLitType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsLitType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_lit_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_lit_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsLitType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_lit_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_lit_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsLitType { span, lit } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLitType(
+                        self,
+                        self::fields::TsLitTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsLit as VisitMutWith<V>>::visit_mut_with(lit, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsLitType(
+                        self,
+                        self::fields::TsLitTypeField::Lit,
+                    ));
+                    <TsLit as VisitWithAstPath<V>>::visit_with_ast_path(
+                        lit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsMappedType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_mapped_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_mapped_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsMappedType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_mapped_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_mapped_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsMappedType {
                 span,
@@ -64771,34 +43834,92 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsMappedType {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
+                        self,
+                        self::fields::TsMappedTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<TruePlusMinus> as VisitMutWith<V>>::visit_mut_with(readonly, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
+                        self,
+                        self::fields::TsMappedTypeField::Readonly,
+                    ));
+                    <Option<TruePlusMinus> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        readonly,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsTypeParam as VisitMutWith<V>>::visit_mut_with(type_param, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
+                        self,
+                        self::fields::TsMappedTypeField::TypeParam,
+                    ));
+                    <TsTypeParam as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(name_type, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
+                        self,
+                        self::fields::TsMappedTypeField::NameType,
+                    ));
+                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<TruePlusMinus> as VisitMutWith<V>>::visit_mut_with(optional, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
+                        self,
+                        self::fields::TsMappedTypeField::Optional,
+                    ));
+                    <Option<TruePlusMinus> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        optional,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsMappedType(
+                        self,
+                        self::fields::TsMappedTypeField::TypeAnn,
+                    ));
+                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsMethodSignature {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_method_signature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_method_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsMethodSignature {
+    #[doc = "Calls [VisitAstPath`::visit_ts_method_signature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_method_signature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsMethodSignature {
                 span,
@@ -64810,53 +43931,131 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsMethodSignature {
                 type_params,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
+                            self,
+                            self::fields::TsMethodSignatureField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
+                            self,
+                            self::fields::TsMethodSignatureField::Key,
+                        ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
+                            self,
+                            self::fields::TsMethodSignatureField::Params(usize::MAX),
+                        ));
+                    <Vec<TsFnParam> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
+                            self,
+                            self::fields::TsMethodSignatureField::TypeAnn,
+                        ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsMethodSignature(
+                            self,
+                            self::fields::TsMethodSignatureField::TypeParams,
+                        ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleBlock {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_module_block`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_module_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleBlock {
+    #[doc = "Calls [VisitAstPath`::visit_ts_module_block`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_block(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsModuleBlock { span, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleBlock(
+                        self,
+                        self::fields::TsModuleBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<ModuleItem> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleBlock(
+                        self,
+                        self::fields::TsModuleBlockField::Body(usize::MAX),
+                    ));
+                    <Vec<ModuleItem> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_module_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_module_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_module_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsModuleDecl {
                 span,
@@ -64866,76 +44065,188 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleDecl {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleDecl(
+                        self,
+                        self::fields::TsModuleDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsModuleName as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleDecl(
+                        self,
+                        self::fields::TsModuleDeclField::Id,
+                    ));
+                    <TsModuleName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<TsNamespaceBody> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleDecl(
+                        self,
+                        self::fields::TsModuleDeclField::Body,
+                    ));
+                    <Option<TsNamespaceBody> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleName {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_module_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_module_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleName {
+    #[doc = "Calls [VisitAstPath`::visit_ts_module_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsModuleName::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleName(
+                    self,
+                    self::fields::TsModuleNameField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsModuleName::Str { 0: _field_0 } => {
-                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleName(
+                    self,
+                    self::fields::TsModuleNameField::Str,
+                ));
+                <Str as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleRef {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_module_ref`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_module_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsModuleRef {
+    #[doc = "Calls [VisitAstPath`::visit_ts_module_ref`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_module_ref(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsModuleRef::TsEntityName { 0: _field_0 } => {
-                <TsEntityName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleRef(
+                    self,
+                    self::fields::TsModuleRefField::TsEntityName,
+                ));
+                <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsModuleRef::TsExternalModuleRef { 0: _field_0 } => {
-                <TsExternalModuleRef as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsModuleRef(
+                    self,
+                    self::fields::TsModuleRefField::TsExternalModuleRef,
+                ));
+                <TsExternalModuleRef as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNamespaceBody {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_namespace_body`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_namespace_body(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNamespaceBody {
+    #[doc = "Calls [VisitAstPath`::visit_ts_namespace_body`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_body(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsNamespaceBody::TsModuleBlock { 0: _field_0 } => {
-                <TsModuleBlock as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceBody(
+                    self,
+                    self::fields::TsNamespaceBodyField::TsModuleBlock,
+                ));
+                <TsModuleBlock as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsNamespaceBody::TsNamespaceDecl { 0: _field_0 } => {
-                <TsNamespaceDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceBody(
+                    self,
+                    self::fields::TsNamespaceBodyField::TsNamespaceDecl,
+                ));
+                <TsNamespaceDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNamespaceDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_namespace_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_namespace_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNamespaceDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_namespace_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsNamespaceDecl {
                 span,
@@ -64945,82 +44256,196 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNamespaceDecl {
                 body,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceDecl(
+                        self,
+                        self::fields::TsNamespaceDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceDecl(
+                        self,
+                        self::fields::TsNamespaceDeclField::Id,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsNamespaceBody> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNamespaceDecl(
+                        self,
+                        self::fields::TsNamespaceDeclField::Body,
+                    ));
+                    <Box<TsNamespaceBody> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNamespaceExportDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_namespace_export_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_namespace_export_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNamespaceExportDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_namespace_export_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_namespace_export_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsNamespaceExportDecl { span, id } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsNamespaceExportDecl(
+                            self,
+                            self::fields::TsNamespaceExportDeclField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsNamespaceExportDecl(
+                            self,
+                            self::fields::TsNamespaceExportDeclField::Id,
+                        ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNonNullExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_non_null_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_non_null_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsNonNullExpr {
+    #[doc = "Calls [VisitAstPath`::visit_ts_non_null_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_non_null_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsNonNullExpr { span, expr } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNonNullExpr(
+                        self,
+                        self::fields::TsNonNullExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsNonNullExpr(
+                        self,
+                        self::fields::TsNonNullExprField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsOptionalType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_optional_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_optional_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsOptionalType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_optional_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_optional_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsOptionalType { span, type_ann } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsOptionalType(
+                        self,
+                        self::fields::TsOptionalTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsOptionalType(
+                        self,
+                        self::fields::TsOptionalTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsParamProp {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_param_prop`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_param_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsParamProp {
+    #[doc = "Calls [VisitAstPath`::visit_ts_param_prop`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_param_prop(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsParamProp {
                 span,
@@ -65031,67 +44456,160 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsParamProp {
                 param,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
+                        self,
+                        self::fields::TsParamPropField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
+                        self,
+                        self::fields::TsParamPropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
+                        self,
+                        self::fields::TsParamPropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitWithAstPath<V>>::visit_with_ast_path(
                         accessibility,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <TsParamPropParam as VisitMutWith<V>>::visit_mut_with(param, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamProp(
+                        self,
+                        self::fields::TsParamPropField::Param,
+                    ));
+                    <TsParamPropParam as VisitWithAstPath<V>>::visit_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsParamPropParam {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_param_prop_param`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_param_prop_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsParamPropParam {
+    #[doc = "Calls [VisitAstPath`::visit_ts_param_prop_param`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_param_prop_param(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsParamPropParam::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamPropParam(
+                    self,
+                    self::fields::TsParamPropParamField::Ident,
+                ));
+                <BindingIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsParamPropParam::Assign { 0: _field_0 } => {
-                <AssignPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsParamPropParam(
+                    self,
+                    self::fields::TsParamPropParamField::Assign,
+                ));
+                <AssignPat as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsParenthesizedType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_parenthesized_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_parenthesized_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsParenthesizedType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_parenthesized_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_parenthesized_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsParenthesizedType { span, type_ann } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsParenthesizedType(
+                            self,
+                            self::fields::TsParenthesizedTypeField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsParenthesizedType(
+                            self,
+                            self::fields::TsParenthesizedTypeField::TypeAnn,
+                        ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsPropertySignature {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_property_signature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_property_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsPropertySignature {
+    #[doc = "Calls [VisitAstPath`::visit_ts_property_signature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_property_signature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsPropertySignature {
                 span,
@@ -65102,66 +44620,163 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsPropertySignature {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsPropertySignature(
+                            self,
+                            self::fields::TsPropertySignatureField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsPropertySignature(
+                            self,
+                            self::fields::TsPropertySignatureField::Key,
+                        ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsPropertySignature(
+                            self,
+                            self::fields::TsPropertySignatureField::TypeAnn,
+                        ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsQualifiedName {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_qualified_name`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_qualified_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsQualifiedName {
+    #[doc = "Calls [VisitAstPath`::visit_ts_qualified_name`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_qualified_name(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsQualifiedName { span, left, right } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsQualifiedName(
+                        self,
+                        self::fields::TsQualifiedNameField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsEntityName as VisitMutWith<V>>::visit_mut_with(left, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsQualifiedName(
+                        self,
+                        self::fields::TsQualifiedNameField::Left,
+                    ));
+                    <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <IdentName as VisitMutWith<V>>::visit_mut_with(right, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsQualifiedName(
+                        self,
+                        self::fields::TsQualifiedNameField::Right,
+                    ));
+                    <IdentName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsRestType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_rest_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_rest_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsRestType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_rest_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_rest_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsRestType { span, type_ann } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsRestType(
+                        self,
+                        self::fields::TsRestTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsRestType(
+                        self,
+                        self::fields::TsRestTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsSatisfiesExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_satisfies_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_satisfies_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsSatisfiesExpr {
+    #[doc = "Calls [VisitAstPath`::visit_ts_satisfies_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_satisfies_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsSatisfiesExpr {
                 span,
@@ -65169,25 +44784,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsSatisfiesExpr {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsSatisfiesExpr(
+                        self,
+                        self::fields::TsSatisfiesExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsSatisfiesExpr(
+                        self,
+                        self::fields::TsSatisfiesExprField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsSatisfiesExpr(
+                        self,
+                        self::fields::TsSatisfiesExprField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsSetterSignature {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_setter_signature`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_setter_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsSetterSignature {
+    #[doc = "Calls [VisitAstPath`::visit_ts_setter_signature`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_setter_signature(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsSetterSignature {
                 span,
@@ -65196,58 +44845,139 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsSetterSignature {
                 param,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsSetterSignature(
+                            self,
+                            self::fields::TsSetterSignatureField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsSetterSignature(
+                            self,
+                            self::fields::TsSetterSignatureField::Key,
+                        ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsFnParam as VisitMutWith<V>>::visit_mut_with(param, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsSetterSignature(
+                            self,
+                            self::fields::TsSetterSignatureField::Param,
+                        ));
+                    <TsFnParam as VisitWithAstPath<V>>::visit_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsThisType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_this_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_this_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsThisType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_this_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_this_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsThisType { span } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsThisType(
+                        self,
+                        self::fields::TsThisTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsThisTypeOrIdent {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_this_type_or_ident`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_this_type_or_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsThisTypeOrIdent {
+    #[doc = "Calls [VisitAstPath`::visit_ts_this_type_or_ident`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_this_type_or_ident(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsThisTypeOrIdent::TsThisType { 0: _field_0 } => {
-                <TsThisType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsThisTypeOrIdent(
+                    self,
+                    self::fields::TsThisTypeOrIdentField::TsThisType,
+                ));
+                <TsThisType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsThisTypeOrIdent::Ident { 0: _field_0 } => {
-                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsThisTypeOrIdent(
+                    self,
+                    self::fields::TsThisTypeOrIdentField::Ident,
+                ));
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTplLitType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_tpl_lit_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_tpl_lit_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTplLitType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_tpl_lit_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tpl_lit_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTplLitType {
                 span,
@@ -65255,137 +44985,401 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTplLitType {
                 quasis,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTplLitType(
+                        self,
+                        self::fields::TsTplLitTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(types, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTplLitType(
+                        self,
+                        self::fields::TsTplLitTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TplElement> as VisitMutWith<V>>::visit_mut_with(quasis, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTplLitType(
+                        self,
+                        self::fields::TsTplLitTypeField::Quasis(usize::MAX),
+                    ));
+                    <Vec<TplElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        quasis,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTupleElement {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_tuple_element`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_tuple_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTupleElement {
+    #[doc = "Calls [VisitAstPath`::visit_ts_tuple_element`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_element(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTupleElement { span, label, ty } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleElement(
+                        self,
+                        self::fields::TsTupleElementField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Pat> as VisitMutWith<V>>::visit_mut_with(label, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleElement(
+                        self,
+                        self::fields::TsTupleElementField::Label,
+                    ));
+                    <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(ty, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleElement(
+                        self,
+                        self::fields::TsTupleElementField::Ty,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ty,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTupleType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_tuple_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_tuple_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTupleType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_tuple_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTupleType { span, elem_types } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleType(
+                        self,
+                        self::fields::TsTupleTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsTupleElement> as VisitMutWith<V>>::visit_mut_with(elem_types, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTupleType(
+                        self,
+                        self::fields::TsTupleTypeField::ElemTypes(usize::MAX),
+                    ));
+                    <Vec<TsTupleElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        elem_types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsType::TsKeywordType { 0: _field_0 } => {
-                <TsKeywordType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsKeywordType,
+                ));
+                <TsKeywordType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsThisType { 0: _field_0 } => {
-                <TsThisType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsThisType,
+                ));
+                <TsThisType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsFnOrConstructorType { 0: _field_0 } => {
-                <TsFnOrConstructorType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsFnOrConstructorType,
+                ));
+                <TsFnOrConstructorType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeRef { 0: _field_0 } => {
-                <TsTypeRef as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsTypeRef,
+                ));
+                <TsTypeRef as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeQuery { 0: _field_0 } => {
-                <TsTypeQuery as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsTypeQuery,
+                ));
+                <TsTypeQuery as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeLit { 0: _field_0 } => {
-                <TsTypeLit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsTypeLit,
+                ));
+                <TsTypeLit as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsArrayType { 0: _field_0 } => {
-                <TsArrayType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsArrayType,
+                ));
+                <TsArrayType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTupleType { 0: _field_0 } => {
-                <TsTupleType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsTupleType,
+                ));
+                <TsTupleType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsOptionalType { 0: _field_0 } => {
-                <TsOptionalType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsOptionalType,
+                ));
+                <TsOptionalType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsRestType { 0: _field_0 } => {
-                <TsRestType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsRestType,
+                ));
+                <TsRestType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsUnionOrIntersectionType { 0: _field_0 } => {
-                <TsUnionOrIntersectionType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsUnionOrIntersectionType,
+                ));
+                <TsUnionOrIntersectionType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsConditionalType { 0: _field_0 } => {
-                <TsConditionalType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsConditionalType,
+                ));
+                <TsConditionalType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsInferType { 0: _field_0 } => {
-                <TsInferType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsInferType,
+                ));
+                <TsInferType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsParenthesizedType { 0: _field_0 } => {
-                <TsParenthesizedType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsParenthesizedType,
+                ));
+                <TsParenthesizedType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeOperator { 0: _field_0 } => {
-                <TsTypeOperator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsTypeOperator,
+                ));
+                <TsTypeOperator as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsIndexedAccessType { 0: _field_0 } => {
-                <TsIndexedAccessType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsIndexedAccessType,
+                ));
+                <TsIndexedAccessType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsMappedType { 0: _field_0 } => {
-                <TsMappedType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsMappedType,
+                ));
+                <TsMappedType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsLitType { 0: _field_0 } => {
-                <TsLitType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsLitType,
+                ));
+                <TsLitType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypePredicate { 0: _field_0 } => {
-                <TsTypePredicate as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsTypePredicate,
+                ));
+                <TsTypePredicate as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsImportType { 0: _field_0 } => {
-                <TsImportType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsType(
+                    self,
+                    self::fields::TsTypeField::TsImportType,
+                ));
+                <TsImportType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAliasDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_alias_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_alias_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAliasDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_alias_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_alias_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeAliasDecl {
                 span,
@@ -65395,50 +45389,115 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAliasDecl {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
+                        self,
+                        self::fields::TsTypeAliasDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
+                        self,
+                        self::fields::TsTypeAliasDeclField::Id,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
+                        self,
+                        self::fields::TsTypeAliasDeclField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as VisitWithAstPath<V>>::visit_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAliasDecl(
+                        self,
+                        self::fields::TsTypeAliasDeclField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAnn {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_ann`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_ann(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAnn {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_ann`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_ann(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeAnn { span, type_ann } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAnn(
+                        self,
+                        self::fields::TsTypeAnnField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAnn(
+                        self,
+                        self::fields::TsTypeAnnField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAssertion {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_assertion`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_assertion(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeAssertion {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_assertion`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_assertion(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeAssertion {
                 span,
@@ -65446,98 +45505,258 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAssertion {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAssertion(
+                        self,
+                        self::fields::TsTypeAssertionField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAssertion(
+                        self,
+                        self::fields::TsTypeAssertionField::Expr,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeAssertion(
+                        self,
+                        self::fields::TsTypeAssertionField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeElement {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_element`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeElement {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_element`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_element(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeElement::TsCallSignatureDecl { 0: _field_0 } => {
-                <TsCallSignatureDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
+                    self,
+                    self::fields::TsTypeElementField::TsCallSignatureDecl,
+                ));
+                <TsCallSignatureDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsConstructSignatureDecl { 0: _field_0 } => {
-                <TsConstructSignatureDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
+                    self,
+                    self::fields::TsTypeElementField::TsConstructSignatureDecl,
+                ));
+                <TsConstructSignatureDecl as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsPropertySignature { 0: _field_0 } => {
-                <TsPropertySignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
+                    self,
+                    self::fields::TsTypeElementField::TsPropertySignature,
+                ));
+                <TsPropertySignature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsGetterSignature { 0: _field_0 } => {
-                <TsGetterSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
+                    self,
+                    self::fields::TsTypeElementField::TsGetterSignature,
+                ));
+                <TsGetterSignature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsSetterSignature { 0: _field_0 } => {
-                <TsSetterSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
+                    self,
+                    self::fields::TsTypeElementField::TsSetterSignature,
+                ));
+                <TsSetterSignature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsMethodSignature { 0: _field_0 } => {
-                <TsMethodSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
+                    self,
+                    self::fields::TsTypeElementField::TsMethodSignature,
+                ));
+                <TsMethodSignature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsIndexSignature { 0: _field_0 } => {
-                <TsIndexSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeElement(
+                    self,
+                    self::fields::TsTypeElementField::TsIndexSignature,
+                ));
+                <TsIndexSignature as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeLit {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_lit`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeLit {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_lit`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_lit(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeLit { span, members } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeLit(
+                        self,
+                        self::fields::TsTypeLitField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsTypeElement> as VisitMutWith<V>>::visit_mut_with(members, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeLit(
+                        self,
+                        self::fields::TsTypeLitField::Members(usize::MAX),
+                    ));
+                    <Vec<TsTypeElement> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        members,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeOperator {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_operator`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeOperator {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_operator`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_operator(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeOperator { span, op, type_ann } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeOperator(
+                        self,
+                        self::fields::TsTypeOperatorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsTypeOperatorOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeOperator(
+                        self,
+                        self::fields::TsTypeOperatorField::Op,
+                    ));
+                    <TsTypeOperatorOp as VisitWithAstPath<V>>::visit_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeOperator(
+                        self,
+                        self::fields::TsTypeOperatorField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeOperatorOp {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_operator_op`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_operator_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeOperatorOp {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_operator_op`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_operator_op(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeOperatorOp::KeyOf => {}
             TsTypeOperatorOp::Unique => {}
@@ -65545,13 +45764,23 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeOperatorOp {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeParam {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_param`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeParam {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_param`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeParam {
                 span,
@@ -65563,66 +45792,162 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeParam {
                 default,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
+                        self,
+                        self::fields::TsTypeParamField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
+                        self,
+                        self::fields::TsTypeParamField::Name,
+                    ));
+                    <Ident as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(constraint, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
+                        self,
+                        self::fields::TsTypeParamField::Constraint,
+                    ));
+                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        constraint,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(default, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParam(
+                        self,
+                        self::fields::TsTypeParamField::Default,
+                    ));
+                    <Option<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        default,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeParamDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_param_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_param_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeParamDecl {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_param_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeParamDecl { span, params } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParamDecl(
+                        self,
+                        self::fields::TsTypeParamDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<TsTypeParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeParamDecl(
+                        self,
+                        self::fields::TsTypeParamDeclField::Params(usize::MAX),
+                    ));
+                    <Vec<TsTypeParam> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeParamInstantiation {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_param_instantiation`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_param_instantiation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeParamInstantiation {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_param_instantiation`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_param_instantiation(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeParamInstantiation { span, params } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsTypeParamInstantiation(
+                            self,
+                            self::fields::TsTypeParamInstantiationField::Span,
+                        ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(params, visitor)
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentNodeRef::TsTypeParamInstantiation(
+                            self,
+                            self::fields::TsTypeParamInstantiationField::Params(usize::MAX),
+                        ));
+                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypePredicate {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_predicate`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_predicate(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypePredicate {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_predicate`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_predicate(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypePredicate {
                 span,
@@ -65631,25 +45956,59 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypePredicate {
                 type_ann,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypePredicate(
+                        self,
+                        self::fields::TsTypePredicateField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsThisTypeOrIdent as VisitMutWith<V>>::visit_mut_with(param_name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypePredicate(
+                        self,
+                        self::fields::TsTypePredicateField::ParamName,
+                    ));
+                    <TsThisTypeOrIdent as VisitWithAstPath<V>>::visit_with_ast_path(
+                        param_name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypePredicate(
+                        self,
+                        self::fields::TsTypePredicateField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeQuery {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_query`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeQuery {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_query`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_query(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeQuery {
                 span,
@@ -65657,44 +46016,98 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeQuery {
                 type_args,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQuery(
+                        self,
+                        self::fields::TsTypeQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <TsTypeQueryExpr as VisitMutWith<V>>::visit_mut_with(expr_name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQuery(
+                        self,
+                        self::fields::TsTypeQueryField::ExprName,
+                    ));
+                    <TsTypeQueryExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                        expr_name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_args, visitor,
-                    )
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQuery(
+                        self,
+                        self::fields::TsTypeQueryField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeQueryExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_query_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_query_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeQueryExpr {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_query_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_query_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeQueryExpr::TsEntityName { 0: _field_0 } => {
-                <TsEntityName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQueryExpr(
+                    self,
+                    self::fields::TsTypeQueryExprField::TsEntityName,
+                ));
+                <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeQueryExpr::Import { 0: _field_0 } => {
-                <TsImportType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeQueryExpr(
+                    self,
+                    self::fields::TsTypeQueryExprField::Import,
+                ));
+                <TsImportType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeRef {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_ref`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsTypeRef {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_ref`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_ref(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsTypeRef {
                 span,
@@ -65702,86 +46115,201 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeRef {
                 type_params,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
-                };
-                {
-                    <TsEntityName as VisitMutWith<V>>::visit_mut_with(type_name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeRef(
+                        self,
+                        self::fields::TsTypeRefField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
-                        type_params,
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeRef(
+                        self,
+                        self::fields::TsTypeRefField::TypeName,
+                    ));
+                    <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
+                        type_name,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsTypeRef(
+                        self,
+                        self::fields::TsTypeRefField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitWithAstPath < V > > :: visit_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsUnionOrIntersectionType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_union_or_intersection_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_union_or_intersection_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsUnionOrIntersectionType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_union_or_intersection_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_union_or_intersection_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsUnionOrIntersectionType::TsUnionType { 0: _field_0 } => {
-                <TsUnionType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::TsUnionOrIntersectionType(
+                        self,
+                        self::fields::TsUnionOrIntersectionTypeField::TsUnionType,
+                    ));
+                <TsUnionType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 } => {
-                <TsIntersectionType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentNodeRef::TsUnionOrIntersectionType(
+                        self,
+                        self::fields::TsUnionOrIntersectionTypeField::TsIntersectionType,
+                    ));
+                <TsIntersectionType as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsUnionType {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_union_type`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_union_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TsUnionType {
+    #[doc = "Calls [VisitAstPath`::visit_ts_union_type`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_union_type(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             TsUnionType { span, types } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsUnionType(
+                        self,
+                        self::fields::TsUnionTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(types, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::TsUnionType(
+                        self,
+                        self::fields::TsUnionTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnaryExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_unary_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_unary_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnaryExpr {
+    #[doc = "Calls [VisitAstPath`::visit_unary_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unary_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UnaryExpr { span, op, arg } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnaryExpr(
+                        self,
+                        self::fields::UnaryExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <UnaryOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnaryExpr(
+                        self,
+                        self::fields::UnaryExprField::Op,
+                    ));
+                    <UnaryOp as VisitWithAstPath<V>>::visit_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UnaryExpr(
+                        self,
+                        self::fields::UnaryExprField::Arg,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnaryOp {
-    #[doc = "Calls [VisitMut`::visit_mut_unary_op`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_unary_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UnaryOp {
+    #[doc = "Calls [VisitAstPath`::visit_unary_op`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_unary_op(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UnaryOp::Minus => {}
             UnaryOp::Plus => {}
@@ -65793,13 +46321,23 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnaryOp {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UpdateExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_update_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_update_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UpdateExpr {
+    #[doc = "Calls [VisitAstPath`::visit_update_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_update_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UpdateExpr {
                 span,
@@ -65808,38 +46346,82 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for UpdateExpr {
                 arg,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UpdateExpr(
+                        self,
+                        self::fields::UpdateExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <UpdateOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UpdateExpr(
+                        self,
+                        self::fields::UpdateExprField::Op,
+                    ));
+                    <UpdateOp as VisitWithAstPath<V>>::visit_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UpdateExpr(
+                        self,
+                        self::fields::UpdateExprField::Arg,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UpdateOp {
-    #[doc = "Calls [VisitMut`::visit_mut_update_op`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_update_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UpdateOp {
+    #[doc = "Calls [VisitAstPath`::visit_update_op`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_update_op(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UpdateOp::PlusPlus => {}
             UpdateOp::MinusMinus => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for UsingDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_using_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_using_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for UsingDecl {
+    #[doc = "Calls [VisitAstPath`::visit_using_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_using_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             UsingDecl {
                 span,
@@ -65847,22 +46429,48 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for UsingDecl {
                 decls,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UsingDecl(
+                        self,
+                        self::fields::UsingDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<VarDeclarator> as VisitMutWith<V>>::visit_mut_with(decls, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::UsingDecl(
+                        self,
+                        self::fields::UsingDeclField::Decls(usize::MAX),
+                    ));
+                    <Vec<VarDeclarator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decls,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDecl {
-    #[doc = "Calls [VisitMut`::visit_mut_var_decl`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_var_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDecl {
+    #[doc = "Calls [VisitAstPath`::visit_var_decl`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             VarDecl {
                 span,
@@ -65872,28 +46480,70 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDecl {
                 decls,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
+                        self,
+                        self::fields::VarDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
+                        self,
+                        self::fields::VarDeclField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitWithAstPath<V>>::visit_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <VarDeclKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
+                        self,
+                        self::fields::VarDeclField::Kind,
+                    ));
+                    <VarDeclKind as VisitWithAstPath<V>>::visit_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Vec<VarDeclarator> as VisitMutWith<V>>::visit_mut_with(decls, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDecl(
+                        self,
+                        self::fields::VarDeclField::Decls(usize::MAX),
+                    ));
+                    <Vec<VarDeclarator> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        decls,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclKind {
-    #[doc = "Calls [VisitMut`::visit_mut_var_decl_kind`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_var_decl_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclKind {
+    #[doc = "Calls [VisitAstPath`::visit_var_decl_kind`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl_kind(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             VarDeclKind::Var => {}
             VarDeclKind::Let => {}
@@ -65901,30 +46551,66 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclKind {
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclOrExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_var_decl_or_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_var_decl_or_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclOrExpr {
+    #[doc = "Calls [VisitAstPath`::visit_var_decl_or_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_decl_or_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             VarDeclOrExpr::VarDecl { 0: _field_0 } => {
-                <Box<VarDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclOrExpr(
+                    self,
+                    self::fields::VarDeclOrExprField::VarDecl,
+                ));
+                <Box<VarDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             VarDeclOrExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclOrExpr(
+                    self,
+                    self::fields::VarDeclOrExprField::Expr,
+                ));
+                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclarator {
-    #[doc = "Calls [VisitMut`::visit_mut_var_declarator`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_var_declarator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for VarDeclarator {
+    #[doc = "Calls [VisitAstPath`::visit_var_declarator`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_declarator(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             VarDeclarator {
                 span,
@@ -65933,69 +46619,171 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclarator {
                 definite,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclarator(
+                        self,
+                        self::fields::VarDeclaratorField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Pat as VisitMutWith<V>>::visit_mut_with(name, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclarator(
+                        self,
+                        self::fields::VarDeclaratorField::Name,
+                    ));
+                    <Pat as VisitWithAstPath<V>>::visit_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(init, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::VarDeclarator(
+                        self,
+                        self::fields::VarDeclaratorField::Init,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for WhileStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_while_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_while_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WhileStmt {
+    #[doc = "Calls [VisitAstPath`::visit_while_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_while_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             WhileStmt { span, test, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WhileStmt(
+                        self,
+                        self::fields::WhileStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WhileStmt(
+                        self,
+                        self::fields::WhileStmtField::Test,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WhileStmt(
+                        self,
+                        self::fields::WhileStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for WithStmt {
-    #[doc = "Calls [VisitMut`::visit_mut_with_stmt`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_with_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WithStmt {
+    #[doc = "Calls [VisitAstPath`::visit_with_stmt`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_with_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             WithStmt { span, obj, body } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WithStmt(
+                        self,
+                        self::fields::WithStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(obj, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WithStmt(
+                        self,
+                        self::fields::WithStmtField::Obj,
+                    ));
+                    <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::WithStmt(
+                        self,
+                        self::fields::WithStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for YieldExpr {
-    #[doc = "Calls [VisitMut`::visit_mut_yield_expr`] with `self`."]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_yield_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for YieldExpr {
+    #[doc = "Calls [VisitAstPath`::visit_yield_expr`] with `self`."]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_yield_expr(visitor, self, __ast_path)
     }
 
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             YieldExpr {
                 span,
@@ -66003,13327 +46791,10517 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for YieldExpr {
                 delegate,
             } => {
                 {
-                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::YieldExpr(
+                        self,
+                        self::fields::YieldExprField::Span,
+                    ));
+                    <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
                 {
-                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
+                    let mut __ast_path = __ast_path.with_guard(AstParentNodeRef::YieldExpr(
+                        self,
+                        self::fields::YieldExprField::Arg,
+                    ));
+                    <Option<Box<Expr>> as VisitWithAstPath<V>>::visit_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
             }
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitMut`::visit_mut_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
+    #[doc = "Calls [VisitAstPath`::visit_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_atom(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         {}
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for BigIntValue {
-    #[doc = "Calls [VisitMut`::visit_mut_big_int_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BigIntValue {
+    #[doc = "Calls [VisitAstPath`::visit_big_int_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_big_int_value(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_big_int_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         {}
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ClassMember> {
-    #[doc = "Calls [VisitMut`::visit_mut_class_members`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ClassMember] {
+    #[doc = "Calls [VisitAstPath`::visit_class_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_class_members(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_class_members(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ClassMember as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ClassMember as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Decorator> {
-    #[doc = "Calls [VisitMut`::visit_mut_decorators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Decorator] {
+    #[doc = "Calls [VisitAstPath`::visit_decorators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_decorators(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_decorators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Decorator as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Decorator as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ExportSpecifier> {
-    #[doc = "Calls [VisitMut`::visit_mut_export_specifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExportSpecifier] {
+    #[doc = "Calls [VisitAstPath`::visit_export_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_export_specifiers(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_export_specifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ExportSpecifier as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ExportSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ExprOrSpread> {
-    #[doc = "Calls [VisitMut`::visit_mut_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExprOrSpread] {
+    #[doc = "Calls [VisitAstPath`::visit_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_expr_or_spreads(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ExprOrSpread as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ExprOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Box<Expr>> {
-    #[doc = "Calls [VisitMut`::visit_mut_exprs`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<Expr>] {
+    #[doc = "Calls [VisitAstPath`::visit_exprs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_exprs(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_exprs(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Box<Expr> as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ImportSpecifier> {
-    #[doc = "Calls [VisitMut`::visit_mut_import_specifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportSpecifier] {
+    #[doc = "Calls [VisitAstPath`::visit_import_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_specifiers(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_specifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ImportSpecifier as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ImportSpecifier as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ImportWithItem> {
-    #[doc = "Calls [VisitMut`::visit_mut_import_with_items`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportWithItem] {
+    #[doc = "Calls [VisitAstPath`::visit_import_with_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_import_with_items(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_import_with_items(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ImportWithItem as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ImportWithItem as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<JSXAttrOrSpread> {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXAttrOrSpread] {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_attr_or_spreads(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_attr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <JSXAttrOrSpread as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <JSXAttrOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<JSXElementChild> {
-    #[doc = "Calls [VisitMut`::visit_mut_jsx_element_childs`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXElementChild] {
+    #[doc = "Calls [VisitAstPath`::visit_jsx_element_childs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_jsx_element_childs(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_jsx_element_childs(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <JSXElementChild as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <JSXElementChild as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ModuleItem> {
-    #[doc = "Calls [VisitMut`::visit_mut_module_items`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ModuleItem] {
+    #[doc = "Calls [VisitAstPath`::visit_module_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_module_items(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_module_items(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ModuleItem as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ModuleItem as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ObjectPatProp> {
-    #[doc = "Calls [VisitMut`::visit_mut_object_pat_props`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ObjectPatProp] {
+    #[doc = "Calls [VisitAstPath`::visit_object_pat_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_object_pat_props(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_object_pat_props(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ObjectPatProp as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ObjectPatProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Accessibility> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_accessibility`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Accessibility> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_accessibility`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_accessibility(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_accessibility(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Accessibility as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Accessibility as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_atom(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <swc_atoms::Atom as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<BlockStmt> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_block_stmt`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<BlockStmt> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_block_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_block_stmt(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_block_stmt(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <BlockStmt as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <BlockStmt as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<CatchClause> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_catch_clause`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<CatchClause> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_catch_clause`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_catch_clause(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_catch_clause(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <CatchClause as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <CatchClause as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Expr>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_expr`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Expr>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_expr(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<Expr> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Box<Expr> as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ExprOrSpread> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_expr_or_spread`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ExprOrSpread> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_expr_or_spread`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_expr_or_spread(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr_or_spread(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <ExprOrSpread as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <ExprOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<ExprOrSpread>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<ExprOrSpread>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_expr_or_spreads(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Vec<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Vec<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Ident> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ident(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ident(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Ident as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Ident as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<JSXAttrValue> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_jsx_attr_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXAttrValue> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_jsx_attr_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_jsx_attr_value(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_jsx_attr_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <JSXAttrValue as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <JSXAttrValue as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<JSXClosingElement> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_jsx_closing_element`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXClosingElement> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_jsx_closing_element`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_jsx_closing_element(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_jsx_closing_element(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <JSXClosingElement as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <JSXClosingElement as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ModuleExportName> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_module_export_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ModuleExportName> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_module_export_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_module_export_name(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_module_export_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <ModuleExportName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <ModuleExportName as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ObjectLit>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_object_lit`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ObjectLit>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_object_lit`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_object_lit(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_object_lit(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<ObjectLit> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Box<ObjectLit> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Pat> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_pat`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Pat> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_pat`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_pat(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_pat(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Pat as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Pat as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_common::Span> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_common::Span> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_span(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <swc_common::Span as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <swc_common::Span as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Stmt>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_stmt`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Stmt>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_stmt(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_stmt(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Box<Stmt> as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Str>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_str`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Str>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_str`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_str(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_str(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<Str> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => {
+                <Box<Str> as VisitWithAstPath<V>>::visit_with_ast_path(inner, visitor, __ast_path)
+            }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TruePlusMinus> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_true_plus_minus`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TruePlusMinus> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_true_plus_minus`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_true_plus_minus(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_true_plus_minus(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <TruePlusMinus as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <TruePlusMinus as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TsEntityName> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_entity_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsEntityName> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ts_entity_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ts_entity_name(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_entity_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <TsEntityName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <TsEntityName as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TsNamespaceBody> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_namespace_body`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsNamespaceBody> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ts_namespace_body`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ts_namespace_body(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_namespace_body(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <TsNamespaceBody as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <TsNamespaceBody as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsType>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsType>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ts_type(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<TsType> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeAnn>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type_ann`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeAnn>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type_ann`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ts_type_ann(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type_ann(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <Box<TsTypeAnn> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <Box<TsTypeAnn> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeParamDecl>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamDecl>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ts_type_param_decl(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type_param_decl(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => {
-                <Box<TsTypeParamDecl> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
-            }
+            Some(inner) => <Box<TsTypeParamDecl> as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeParamInstantiation>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type_param_instantiation`] with `self`. (Extra \
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamInstantiation>> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_ts_type_param_instantiation`] with `self`. (Extra \
              impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
             Some(inner) => {
-                <Box<TsTypeParamInstantiation> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
+                <Box<TsTypeParamInstantiation> as VisitWithAstPath<V>>::visit_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
             }
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<VarDeclOrExpr> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<VarDeclOrExpr> {
+    #[doc = "Calls [VisitAstPath`::visit_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_var_decl_or_expr(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_var_decl_or_expr(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
         match self {
-            Some(inner) => <VarDeclOrExpr as VisitMutWith<V>>::visit_mut_with(inner, visitor),
+            Some(inner) => <VarDeclOrExpr as VisitWithAstPath<V>>::visit_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
             None => {}
         }
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Option<ExprOrSpread>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<ExprOrSpread>] {
+    #[doc = "Calls [VisitAstPath`::visit_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut().for_each(|item| {
-            <Option<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(item, visitor)
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Option<ExprOrSpread> as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Option<Pat>> {
-    #[doc = "Calls [VisitMut`::visit_mut_opt_vec_pats`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<Pat>] {
+    #[doc = "Calls [VisitAstPath`::visit_opt_vec_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_opt_vec_pats(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_opt_vec_pats(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Option<Pat> as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Option<Pat> as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ParamOrTsParamProp> {
-    #[doc = "Calls [VisitMut`::visit_mut_param_or_ts_param_props`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ParamOrTsParamProp] {
+    #[doc = "Calls [VisitAstPath`::visit_param_or_ts_param_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_param_or_ts_param_props(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_param_or_ts_param_props(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <ParamOrTsParamProp as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ParamOrTsParamProp as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Param> {
-    #[doc = "Calls [VisitMut`::visit_mut_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Param] {
+    #[doc = "Calls [VisitAstPath`::visit_params`] with `self`. (Extra impl)"]
+    #[inline]
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_params(visitor, self, __ast_path)
+    }
+
+    #[inline]
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Param as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
+    }
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Pat] {
+    #[doc = "Calls [VisitAstPath`::visit_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_params(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_pats(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Param as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Pat as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Pat> {
-    #[doc = "Calls [VisitMut`::visit_mut_pats`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PropOrSpread] {
+    #[doc = "Calls [VisitAstPath`::visit_prop_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_pats(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_prop_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Pat as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PropOrSpread as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PropOrSpread> {
-    #[doc = "Calls [VisitMut`::visit_mut_prop_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
+    #[doc = "Calls [VisitAstPath`::visit_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_prop_or_spreads(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <PropOrSpread as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        {}
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_common::Span {
-    #[doc = "Calls [VisitMut`::visit_mut_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Stmt] {
+    #[doc = "Calls [VisitAstPath`::visit_stmts`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_span(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_stmts(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        {}
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Stmt as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Stmt> {
-    #[doc = "Calls [VisitMut`::visit_mut_stmts`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SwitchCase] {
+    #[doc = "Calls [VisitAstPath`::visit_switch_cases`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_stmts(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_switch_cases(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Stmt as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <SwitchCase as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SwitchCase> {
-    #[doc = "Calls [VisitMut`::visit_mut_switch_cases`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::SyntaxContext {
+    #[doc = "Calls [VisitAstPath`::visit_syntax_context`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_switch_cases(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_syntax_context(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <SwitchCase as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        {}
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_common::SyntaxContext {
-    #[doc = "Calls [VisitMut`::visit_mut_syntax_context`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TplElement] {
+    #[doc = "Calls [VisitAstPath`::visit_tpl_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_syntax_context(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_tpl_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        {}
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TplElement as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TplElement> {
-    #[doc = "Calls [VisitMut`::visit_mut_tpl_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsEnumMember] {
+    #[doc = "Calls [VisitAstPath`::visit_ts_enum_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_tpl_elements(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_enum_members(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <TplElement as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsEnumMember as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsEnumMember> {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_members`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsExprWithTypeArgs] {
+    #[doc = "Calls [VisitAstPath`::visit_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_enum_members(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_expr_with_type_argss(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <TsEnumMember as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsExprWithTypeArgs as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsExprWithTypeArgs> {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsFnParam] {
+    #[doc = "Calls [VisitAstPath`::visit_ts_fn_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_expr_with_type_argss(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_fn_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <TsExprWithTypeArgs as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsFnParam as VisitWithAstPath<V>>::visit_with_ast_path(item, visitor, &mut *__ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsFnParam> {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTupleElement] {
+    #[doc = "Calls [VisitAstPath`::visit_ts_tuple_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_fn_params(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_tuple_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <TsFnParam as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsTupleElement as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTupleElement> {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_tuple_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeElement] {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_tuple_elements(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <TsTupleElement as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsTypeElement as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTypeElement> {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeParam] {
+    #[doc = "Calls [VisitAstPath`::visit_ts_type_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_elements(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_type_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <TsTypeElement as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsTypeParam as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTypeParam> {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_type_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<TsType>] {
+    #[doc = "Calls [VisitAstPath`::visit_ts_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_type_params(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_ts_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <TsTypeParam as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Box<TsType> as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Box<TsType>> {
-    #[doc = "Calls [VisitMut`::visit_mut_ts_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [VarDeclarator] {
+    #[doc = "Calls [VisitAstPath`::visit_var_declarators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_ts_types(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        <V as VisitAstPath>::visit_var_declarators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <Box<TsType> as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        self.iter().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <VarDeclarator as VisitWithAstPath<V>>::visit_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<VarDeclarator> {
-    #[doc = "Calls [VisitMut`::visit_mut_var_declarators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> VisitWithAstPath<V> for std::boxed::Box<T>
+where
+    V: ?Sized + VisitAstPath,
+    T: VisitWithAstPath<V>,
+{
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        <V as VisitMut>::visit_mut_var_declarators(visitor, self)
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v = <T as VisitWithAstPath<V>>::visit_with_ast_path(&**self, visitor, __ast_path);
+        v
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        self.iter_mut()
-            .for_each(|item| <VarDeclarator as VisitMutWith<V>>::visit_mut_with(item, visitor))
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v =
+            <T as VisitWithAstPath<V>>::visit_children_with_ast_path(&**self, visitor, __ast_path);
+        v
     }
 }
-impl<V, T> VisitMutWith<V> for std::boxed::Box<T>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> VisitWithAstPath<V> for std::vec::Vec<T>
 where
-    V: ?Sized + VisitMut,
-    T: VisitMutWith<V>,
+    V: ?Sized + VisitAstPath,
+    [T]: VisitWithAstPath<V>,
 {
     #[inline]
-    fn visit_mut_with(&mut self, visitor: &mut V) {
-        let v = <T as VisitMutWith<V>>::visit_mut_with(&mut **self, visitor);
+    fn visit_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v = <[T] as VisitWithAstPath<V>>::visit_with_ast_path(self, visitor, __ast_path);
         v
     }
 
     #[inline]
-    fn visit_mut_children_with(&mut self, visitor: &mut V) {
-        let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
+    fn visit_children_with_ast_path<'ast: 'r, 'r>(
+        &'ast self,
+        visitor: &mut V,
+        __ast_path: &mut AstNodePath<'r>,
+    ) {
+        let v =
+            <[T] as VisitWithAstPath<V>>::visit_children_with_ast_path(self, visitor, __ast_path);
         v
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitMutAstPath {
+pub trait VisitMut {
     #[doc = "Visit a node of type `Accessibility`.\n\nBy default, this method calls \
-             [`Accessibility::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Accessibility::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
-        <Accessibility as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
+        <Accessibility as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrayLit`.\n\nBy default, this method calls \
-             [`ArrayLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ArrayLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
-        <ArrayLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
+        <ArrayLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrayPat`.\n\nBy default, this method calls \
-             [`ArrayPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ArrayPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
-        <ArrayPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
+        <ArrayPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrowExpr`.\n\nBy default, this method calls \
-             [`ArrowExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ArrowExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
-        <ArrowExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
+        <ArrowExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignExpr`.\n\nBy default, this method calls \
-             [`AssignExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
-        <AssignExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
+        <AssignExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignOp`.\n\nBy default, this method calls \
-             [`AssignOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
-        <AssignOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
+        <AssignOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignPat`.\n\nBy default, this method calls \
-             [`AssignPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
-        <AssignPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
+        <AssignPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignPatProp`.\n\nBy default, this method calls \
-             [`AssignPatProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AssignPatProp::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_assign_pat_prop(
-        &mut self,
-        node: &mut AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AssignPatProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
+        <AssignPatProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignProp`.\n\nBy default, this method calls \
-             [`AssignProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
-        <AssignProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
+        <AssignProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignTarget`.\n\nBy default, this method calls \
-             [`AssignTarget::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AssignTarget::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
-        <AssignTarget as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
+        <AssignTarget as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignTargetPat`.\n\nBy default, this method calls \
-             [`AssignTargetPat::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`AssignTargetPat::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_assign_target_pat(
-        &mut self,
-        node: &mut AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <AssignTargetPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
+        <AssignTargetPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`swc_atoms :: Atom::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
-        <swc_atoms::Atom as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+        <swc_atoms::Atom as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AutoAccessor`.\n\nBy default, this method calls \
-             [`AutoAccessor::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`AutoAccessor::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
-        <AutoAccessor as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
+        <AutoAccessor as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AwaitExpr`.\n\nBy default, this method calls \
-             [`AwaitExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AwaitExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
-        <AwaitExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
+        <AwaitExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BigInt`.\n\nBy default, this method calls \
-             [`BigInt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BigInt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
-        <BigInt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
+        <BigInt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BigIntValue`.\n\nBy default, this method calls \
-             [`BigIntValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`BigIntValue::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
-        <BigIntValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
+        <BigIntValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinExpr`.\n\nBy default, this method calls \
-             [`BinExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BinExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
-        <BinExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
+        <BinExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinaryOp`.\n\nBy default, this method calls \
-             [`BinaryOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BinaryOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
-        <BinaryOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
+        <BinaryOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BindingIdent`.\n\nBy default, this method calls \
-             [`BindingIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`BindingIdent::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
-        <BindingIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
+        <BindingIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BlockStmt`.\n\nBy default, this method calls \
-             [`BlockStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BlockStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
-        <BlockStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
+        <BlockStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BlockStmtOrExpr`.\n\nBy default, this method calls \
-             [`BlockStmtOrExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`BlockStmtOrExpr::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_block_stmt_or_expr(
-        &mut self,
-        node: &mut BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <BlockStmtOrExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
+        <BlockStmtOrExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Bool`.\n\nBy default, this method calls \
-             [`Bool::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Bool::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
-        <Bool as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_bool(&mut self, node: &mut Bool) {
+        <Bool as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `BreakStmt`.\n\nBy default, this method calls \
-             [`BreakStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BreakStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
-        <BreakStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
+        <BreakStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CallExpr`.\n\nBy default, this method calls \
-             [`CallExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CallExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
-        <CallExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
+        <CallExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Callee`.\n\nBy default, this method calls \
-             [`Callee::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Callee::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
-        <Callee as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_callee(&mut self, node: &mut Callee) {
+        <Callee as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CatchClause`.\n\nBy default, this method calls \
-             [`CatchClause::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`CatchClause::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
-        <CatchClause as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
+        <CatchClause as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Class`.\n\nBy default, this method calls \
-             [`Class::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Class::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
-        <Class as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class(&mut self, node: &mut Class) {
+        <Class as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassDecl`.\n\nBy default, this method calls \
-             [`ClassDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ClassDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
-        <ClassDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
+        <ClassDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassExpr`.\n\nBy default, this method calls \
-             [`ClassExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ClassExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
-        <ClassExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
+        <ClassExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassMember`.\n\nBy default, this method calls \
-             [`ClassMember::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ClassMember::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
-        <ClassMember as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
+        <ClassMember as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ClassMember >`.\n\nBy default, this method calls [`Vec < \
-             ClassMember >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             ClassMember >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_class_members(
-        &mut self,
-        node: &mut Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ClassMember> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
+        <Vec<ClassMember> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassMethod`.\n\nBy default, this method calls \
-             [`ClassMethod::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ClassMethod::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
-        <ClassMethod as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
+        <ClassMethod as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassProp`.\n\nBy default, this method calls \
-             [`ClassProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ClassProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
-        <ClassProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
+        <ClassProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComputedPropName`.\n\nBy default, this method calls \
-             [`ComputedPropName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ComputedPropName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_computed_prop_name(
-        &mut self,
-        node: &mut ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ComputedPropName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
+        <ComputedPropName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CondExpr`.\n\nBy default, this method calls \
-             [`CondExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CondExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
-        <CondExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
+        <CondExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Constructor`.\n\nBy default, this method calls \
-             [`Constructor::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Constructor::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
-        <Constructor as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
+        <Constructor as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContinueStmt`.\n\nBy default, this method calls \
-             [`ContinueStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ContinueStmt::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
-        <ContinueStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
+        <ContinueStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DebuggerStmt`.\n\nBy default, this method calls \
-             [`DebuggerStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`DebuggerStmt::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
-        <DebuggerStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
+        <DebuggerStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Decl`.\n\nBy default, this method calls \
-             [`Decl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Decl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
-        <Decl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_decl(&mut self, node: &mut Decl) {
+        <Decl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Decorator`.\n\nBy default, this method calls \
-             [`Decorator::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Decorator::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
-        <Decorator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
+        <Decorator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Decorator >`.\n\nBy default, this method calls [`Vec < \
-             Decorator >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             Decorator >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
-        <Vec<Decorator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
+        <Vec<Decorator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DefaultDecl`.\n\nBy default, this method calls \
-             [`DefaultDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`DefaultDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
-        <DefaultDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
+        <DefaultDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DoWhileStmt`.\n\nBy default, this method calls \
-             [`DoWhileStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`DoWhileStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
-        <DoWhileStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
+        <DoWhileStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `EmptyStmt`.\n\nBy default, this method calls \
-             [`EmptyStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`EmptyStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
-        <EmptyStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
+        <EmptyStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `EsVersion`.\n\nBy default, this method calls \
-             [`EsVersion::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`EsVersion::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
-        <EsVersion as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
+        <EsVersion as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportAll`.\n\nBy default, this method calls \
-             [`ExportAll::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportAll::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
-        <ExportAll as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
+        <ExportAll as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDecl`.\n\nBy default, this method calls \
-             [`ExportDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
-        <ExportDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
+        <ExportDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultDecl`.\n\nBy default, this method calls \
-             [`ExportDefaultDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ExportDefaultDecl::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_export_default_decl(
-        &mut self,
-        node: &mut ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ExportDefaultDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
+        <ExportDefaultDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultExpr`.\n\nBy default, this method calls \
-             [`ExportDefaultExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ExportDefaultExpr::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_export_default_expr(
-        &mut self,
-        node: &mut ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ExportDefaultExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
+        <ExportDefaultExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ExportDefaultSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ExportDefaultSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_export_default_specifier(
-        &mut self,
-        node: &mut ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ExportDefaultSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
+        <ExportDefaultSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamedSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ExportNamedSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_export_named_specifier(
-        &mut self,
-        node: &mut ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ExportNamedSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
+        <ExportNamedSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportNamespaceSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamespaceSpecifier::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`ExportNamespaceSpecifier::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_export_namespace_specifier(
-        &mut self,
-        node: &mut ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ExportNamespaceSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
+        <ExportNamespaceSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportSpecifier`.\n\nBy default, this method calls \
-             [`ExportSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ExportSpecifier::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_export_specifier(
-        &mut self,
-        node: &mut ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ExportSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
+        <ExportSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ExportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ExportSpecifier >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < ExportSpecifier >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_export_specifiers(
-        &mut self,
-        node: &mut Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ExportSpecifier> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
+        <Vec<ExportSpecifier> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Expr`.\n\nBy default, this method calls \
-             [`Expr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Expr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
-        <Expr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_expr(&mut self, node: &mut Expr) {
+        <Expr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExprOrSpread`.\n\nBy default, this method calls \
-             [`ExprOrSpread::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ExprOrSpread::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
-        <ExprOrSpread as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
+        <ExprOrSpread as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ExprOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             ExprOrSpread >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             ExprOrSpread >::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ExprOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
+        <Vec<ExprOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExprStmt`.\n\nBy default, this method calls \
-             [`ExprStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExprStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
-        <ExprStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
+        <ExprStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Box < Expr > >`.\n\nBy default, this method calls [`Vec < \
-             Box < Expr > >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             Box < Expr > >::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
-        <Vec<Box<Expr>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
+        <Vec<Box<Expr>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `FnDecl`.\n\nBy default, this method calls \
-             [`FnDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`FnDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
-        <FnDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
+        <FnDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `FnExpr`.\n\nBy default, this method calls \
-             [`FnExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`FnExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
-        <FnExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
+        <FnExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForHead`.\n\nBy default, this method calls \
-             [`ForHead::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ForHead::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
-        <ForHead as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
+        <ForHead as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForInStmt`.\n\nBy default, this method calls \
-             [`ForInStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ForInStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
-        <ForInStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
+        <ForInStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForOfStmt`.\n\nBy default, this method calls \
-             [`ForOfStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ForOfStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
-        <ForOfStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
+        <ForOfStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForStmt`.\n\nBy default, this method calls \
-             [`ForStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ForStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
-        <ForStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
+        <ForStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Function::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
-        <Function as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_function(&mut self, node: &mut Function) {
+        <Function as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `GetterProp`.\n\nBy default, this method calls \
-             [`GetterProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`GetterProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
-        <GetterProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
+        <GetterProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Ident::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
-        <Ident as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
+        <Ident as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `IdentName`.\n\nBy default, this method calls \
-             [`IdentName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`IdentName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
-        <IdentName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
+        <IdentName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `IfStmt`.\n\nBy default, this method calls \
-             [`IfStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`IfStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
-        <IfStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
+        <IfStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Import`.\n\nBy default, this method calls \
-             [`Import::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Import::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
-        <Import as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import(&mut self, node: &mut Import) {
+        <Import as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportDecl`.\n\nBy default, this method calls \
-             [`ImportDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
-        <ImportDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
+        <ImportDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ImportDefaultSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ImportDefaultSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_import_default_specifier(
-        &mut self,
-        node: &mut ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ImportDefaultSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
+        <ImportDefaultSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ImportNamedSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ImportNamedSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_import_named_specifier(
-        &mut self,
-        node: &mut ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ImportNamedSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
+        <ImportNamedSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportPhase`.\n\nBy default, this method calls \
-             [`ImportPhase::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ImportPhase::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
-        <ImportPhase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
+        <ImportPhase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportSpecifier`.\n\nBy default, this method calls \
-             [`ImportSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ImportSpecifier::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_specifier(
-        &mut self,
-        node: &mut ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ImportSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
+        <ImportSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ImportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ImportSpecifier >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < ImportSpecifier >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_import_specifiers(
-        &mut self,
-        node: &mut Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ImportSpecifier> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
+        <Vec<ImportSpecifier> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportStarAsSpecifier`.\n\nBy default, this method calls \
-             [`ImportStarAsSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ImportStarAsSpecifier::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_import_star_as_specifier(
-        &mut self,
-        node: &mut ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ImportStarAsSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
+        <ImportStarAsSpecifier as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportWith`.\n\nBy default, this method calls \
-             [`ImportWith::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportWith::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
-        <ImportWith as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
+        <ImportWith as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
-             [`ImportWithItem::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ImportWithItem::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_import_with_item(
-        &mut self,
-        node: &mut ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ImportWithItem as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
+        <ImportWithItem as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ImportWithItem >`.\n\nBy default, this method calls [`Vec \
-             < ImportWithItem >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < ImportWithItem >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_import_with_items(
-        &mut self,
-        node: &mut Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ImportWithItem> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
+        <Vec<ImportWithItem> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Invalid`.\n\nBy default, this method calls \
-             [`Invalid::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Invalid::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
-        <Invalid as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
+        <Invalid as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttr`.\n\nBy default, this method calls \
-             [`JSXAttr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXAttr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
-        <JSXAttr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
+        <JSXAttr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrName`.\n\nBy default, this method calls \
-             [`JSXAttrName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXAttrName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
-        <JSXAttrName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
+        <JSXAttrName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrOrSpread`.\n\nBy default, this method calls \
-             [`JSXAttrOrSpread::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXAttrOrSpread::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(
-        &mut self,
-        node: &mut JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXAttrOrSpread as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
+        <JSXAttrOrSpread as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < JSXAttrOrSpread >`.\n\nBy default, this method calls \
-             [`Vec < JSXAttrOrSpread >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < JSXAttrOrSpread >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(
-        &mut self,
-        node: &mut Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<JSXAttrOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
+        <Vec<JSXAttrOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrValue`.\n\nBy default, this method calls \
-             [`JSXAttrValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXAttrValue::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
-        <JSXAttrValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
+        <JSXAttrValue as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXClosingElement`.\n\nBy default, this method calls \
-             [`JSXClosingElement::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXClosingElement::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_closing_element(
-        &mut self,
-        node: &mut JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXClosingElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
+        <JSXClosingElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXClosingFragment`.\n\nBy default, this method calls \
-             [`JSXClosingFragment::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXClosingFragment::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_closing_fragment(
-        &mut self,
-        node: &mut JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXClosingFragment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
+        <JSXClosingFragment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElement`.\n\nBy default, this method calls \
-             [`JSXElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXElement::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
-        <JSXElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
+        <JSXElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElementChild`.\n\nBy default, this method calls \
-             [`JSXElementChild::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXElementChild::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_element_child(
-        &mut self,
-        node: &mut JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXElementChild as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
+        <JSXElementChild as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < JSXElementChild >`.\n\nBy default, this method calls \
-             [`Vec < JSXElementChild >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < JSXElementChild >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_jsx_element_childs(
-        &mut self,
-        node: &mut Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<JSXElementChild> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
+        <Vec<JSXElementChild> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElementName`.\n\nBy default, this method calls \
-             [`JSXElementName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXElementName::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_element_name(
-        &mut self,
-        node: &mut JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXElementName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
+        <JSXElementName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXEmptyExpr`.\n\nBy default, this method calls \
-             [`JSXEmptyExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXEmptyExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
-        <JSXEmptyExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
+        <JSXEmptyExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXExpr`.\n\nBy default, this method calls \
-             [`JSXExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
-        <JSXExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
+        <JSXExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
-             [`JSXExprContainer::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXExprContainer::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_expr_container(
-        &mut self,
-        node: &mut JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXExprContainer as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
+        <JSXExprContainer as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXFragment`.\n\nBy default, this method calls \
-             [`JSXFragment::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXFragment::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
-        <JSXFragment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
+        <JSXFragment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXMemberExpr`.\n\nBy default, this method calls \
-             [`JSXMemberExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXMemberExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_member_expr(
-        &mut self,
-        node: &mut JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXMemberExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
+        <JSXMemberExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXNamespacedName`.\n\nBy default, this method calls \
-             [`JSXNamespacedName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXNamespacedName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_namespaced_name(
-        &mut self,
-        node: &mut JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXNamespacedName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
+        <JSXNamespacedName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXObject`.\n\nBy default, this method calls \
-             [`JSXObject::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXObject::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
-        <JSXObject as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
+        <JSXObject as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXOpeningElement`.\n\nBy default, this method calls \
-             [`JSXOpeningElement::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXOpeningElement::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_opening_element(
-        &mut self,
-        node: &mut JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXOpeningElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
+        <JSXOpeningElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXOpeningFragment`.\n\nBy default, this method calls \
-             [`JSXOpeningFragment::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXOpeningFragment::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_jsx_opening_fragment(
-        &mut self,
-        node: &mut JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXOpeningFragment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
+        <JSXOpeningFragment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXSpreadChild`.\n\nBy default, this method calls \
-             [`JSXSpreadChild::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`JSXSpreadChild::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_jsx_spread_child(
-        &mut self,
-        node: &mut JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <JSXSpreadChild as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
+        <JSXSpreadChild as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXText`.\n\nBy default, this method calls \
-             [`JSXText::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXText::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
-        <JSXText as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
+        <JSXText as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Key`.\n\nBy default, this method calls \
-             [`Key::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Key::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
-        <Key as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_key(&mut self, node: &mut Key) {
+        <Key as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyValuePatProp`.\n\nBy default, this method calls \
-             [`KeyValuePatProp::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`KeyValuePatProp::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_key_value_pat_prop(
-        &mut self,
-        node: &mut KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <KeyValuePatProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
+        <KeyValuePatProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyValueProp`.\n\nBy default, this method calls \
-             [`KeyValueProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`KeyValueProp::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
-        <KeyValueProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
+        <KeyValueProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `LabeledStmt`.\n\nBy default, this method calls \
-             [`LabeledStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`LabeledStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
-        <LabeledStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
+        <LabeledStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Lit`.\n\nBy default, this method calls \
-             [`Lit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Lit::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
-        <Lit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_lit(&mut self, node: &mut Lit) {
+        <Lit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MemberExpr`.\n\nBy default, this method calls \
-             [`MemberExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MemberExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
-        <MemberExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
+        <MemberExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MemberProp`.\n\nBy default, this method calls \
-             [`MemberProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MemberProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
-        <MemberProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
+        <MemberProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MetaPropExpr`.\n\nBy default, this method calls \
-             [`MetaPropExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MetaPropExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
-        <MetaPropExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
+        <MetaPropExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MetaPropKind`.\n\nBy default, this method calls \
-             [`MetaPropKind::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`MetaPropKind::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
-        <MetaPropKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
+        <MetaPropKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MethodKind`.\n\nBy default, this method calls \
-             [`MethodKind::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MethodKind::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
-        <MethodKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
+        <MethodKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `MethodProp`.\n\nBy default, this method calls \
-             [`MethodProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MethodProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
-        <MethodProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
+        <MethodProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Module`.\n\nBy default, this method calls \
-             [`Module::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Module::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
-        <Module as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_module(&mut self, node: &mut Module) {
+        <Module as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleDecl`.\n\nBy default, this method calls \
-             [`ModuleDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ModuleDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
-        <ModuleDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
+        <ModuleDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleExportName`.\n\nBy default, this method calls \
-             [`ModuleExportName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ModuleExportName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_module_export_name(
-        &mut self,
-        node: &mut ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ModuleExportName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
+        <ModuleExportName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleItem`.\n\nBy default, this method calls \
-             [`ModuleItem::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ModuleItem::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
-        <ModuleItem as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
+        <ModuleItem as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ModuleItem >`.\n\nBy default, this method calls [`Vec < \
-             ModuleItem >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             ModuleItem >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
-        <Vec<ModuleItem> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
+        <Vec<ModuleItem> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamedExport`.\n\nBy default, this method calls \
-             [`NamedExport::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`NamedExport::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
-        <NamedExport as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
+        <NamedExport as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `NewExpr`.\n\nBy default, this method calls \
-             [`NewExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`NewExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
-        <NewExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
+        <NewExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Null`.\n\nBy default, this method calls \
-             [`Null::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Null::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
-        <Null as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_null(&mut self, node: &mut Null) {
+        <Null as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Number::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
-        <Number as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_number(&mut self, node: &mut Number) {
+        <Number as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectLit`.\n\nBy default, this method calls \
-             [`ObjectLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ObjectLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
-        <ObjectLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
+        <ObjectLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectPat`.\n\nBy default, this method calls \
-             [`ObjectPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ObjectPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
-        <ObjectPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
+        <ObjectPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectPatProp`.\n\nBy default, this method calls \
-             [`ObjectPatProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ObjectPatProp::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_object_pat_prop(
-        &mut self,
-        node: &mut ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ObjectPatProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
+        <ObjectPatProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ObjectPatProp >`.\n\nBy default, this method calls [`Vec \
-             < ObjectPatProp >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < ObjectPatProp >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_object_pat_props(
-        &mut self,
-        node: &mut Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ObjectPatProp> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
+        <Vec<ObjectPatProp> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Accessibility >`.\n\nBy default, this method calls \
-             [`Option < Accessibility >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Accessibility >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_accessibility(
-        &mut self,
-        node: &mut Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Accessibility> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
+        <Option<Accessibility> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < swc_atoms :: Atom >::visit_mut_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<swc_atoms::Atom> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+        <Option<swc_atoms::Atom> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < BlockStmt >`.\n\nBy default, this method calls \
-             [`Option < BlockStmt >::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < BlockStmt >::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_block_stmt(
-        &mut self,
-        node: &mut Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<BlockStmt> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
+        <Option<BlockStmt> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptCall`.\n\nBy default, this method calls \
-             [`OptCall::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`OptCall::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
-        <OptCall as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
+        <OptCall as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
-             [`Option < CatchClause >::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < CatchClause >::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_catch_clause(
-        &mut self,
-        node: &mut Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<CatchClause> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
+        <Option<CatchClause> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptChainBase`.\n\nBy default, this method calls \
-             [`OptChainBase::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`OptChainBase::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
-        <OptChainBase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
+        <OptChainBase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptChainExpr`.\n\nBy default, this method calls \
-             [`OptChainExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`OptChainExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
-        <OptChainExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
+        <OptChainExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Expr > >`.\n\nBy default, this method calls \
-             [`Option < Box < Expr > >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < Expr > >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
-        <Option<Box<Expr>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
+        <Option<Box<Expr>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ExprOrSpread >`.\n\nBy default, this method calls \
-             [`Option < ExprOrSpread >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < ExprOrSpread >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_expr_or_spread(
-        &mut self,
-        node: &mut Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<ExprOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
+        <Option<ExprOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Option < Vec < ExprOrSpread > >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < Vec < ExprOrSpread > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(
-        &mut self,
-        node: &mut Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Vec<ExprOrSpread>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
+        <Option<Vec<ExprOrSpread>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             Ident >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
-        <Option<Ident> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+        <Option<Ident> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
-    #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
-             [`Option < JSXAttrValue >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
-    #[inline]
-    fn visit_mut_opt_jsx_attr_value(
-        &mut self,
-        node: &mut Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<JSXAttrValue> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
+             [`Option < JSXAttrValue >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
+    #[inline]
+    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
+        <Option<JSXAttrValue> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < JSXClosingElement >`.\n\nBy default, this method calls \
-             [`Option < JSXClosingElement >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < JSXClosingElement >::visit_mut_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(
-        &mut self,
-        node: &mut Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<JSXClosingElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
+        <Option<JSXClosingElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ModuleExportName >`.\n\nBy default, this method calls \
-             [`Option < ModuleExportName >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < ModuleExportName >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_module_export_name(
-        &mut self,
-        node: &mut Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<ModuleExportName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
+        <Option<ModuleExportName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ObjectLit > >`.\n\nBy default, this method calls \
-             [`Option < Box < ObjectLit > >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < ObjectLit > >::visit_mut_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_object_lit(
-        &mut self,
-        node: &mut Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<ObjectLit>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
+        <Option<Box<ObjectLit>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Pat >`.\n\nBy default, this method calls [`Option < \
-             Pat >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             Pat >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
-        <Option<Pat> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
+        <Option<Pat> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < swc_common :: Span >`.\n\nBy default, this method \
-             calls [`Option < swc_common :: Span >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < swc_common :: Span >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_span(
-        &mut self,
-        node: &mut Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<swc_common::Span> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
+        <Option<swc_common::Span> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Stmt > >`.\n\nBy default, this method calls \
-             [`Option < Box < Stmt > >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < Stmt > >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
-        <Option<Box<Stmt>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
+        <Option<Box<Stmt>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Str > >`.\n\nBy default, this method calls \
-             [`Option < Box < Str > >::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Box < Str > >::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
-        <Option<Box<Str>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
+        <Option<Box<Str>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TruePlusMinus >`.\n\nBy default, this method calls \
-             [`Option < TruePlusMinus >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < TruePlusMinus >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_true_plus_minus(
-        &mut self,
-        node: &mut Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<TruePlusMinus> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
+        <Option<TruePlusMinus> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TsEntityName >`.\n\nBy default, this method calls \
-             [`Option < TsEntityName >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < TsEntityName >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_entity_name(
-        &mut self,
-        node: &mut Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<TsEntityName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
+        <Option<TsEntityName> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TsNamespaceBody >`.\n\nBy default, this method calls \
-             [`Option < TsNamespaceBody >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < TsNamespaceBody >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(
-        &mut self,
-        node: &mut Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<TsNamespaceBody> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
+        <Option<TsNamespaceBody> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsType > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsType > >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < TsType > >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_type(
-        &mut self,
-        node: &mut Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<TsType>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
+        <Option<Box<TsType>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeAnn > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsTypeAnn > >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < TsTypeAnn > >::visit_mut_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_type_ann(
-        &mut self,
-        node: &mut Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
+        <Option<Box<TsTypeAnn>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamDecl > >`.\n\nBy default, this method \
-             calls [`Option < Box < TsTypeParamDecl > >::visit_mut_children_with_ast_path`]. If \
-             you want to recurse, you need to call it manually."]
+             calls [`Option < Box < TsTypeParamDecl > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(
-        &mut self,
-        node: &mut Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
+        <Option<Box<TsTypeParamDecl>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamInstantiation > >`.\n\nBy default, \
              this method calls [`Option < Box < TsTypeParamInstantiation > \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
     fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
         node: &mut Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) {
-        < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
+        <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<Self>>::visit_mut_children_with(
+            node, self,
+        )
     }
     #[doc = "Visit a node of type `Option < VarDeclOrExpr >`.\n\nBy default, this method calls \
-             [`Option < VarDeclOrExpr >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < VarDeclOrExpr >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(
-        &mut self,
-        node: &mut Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Option<VarDeclOrExpr> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
+        <Option<VarDeclOrExpr> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Option < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Vec < Option < ExprOrSpread > >::visit_mut_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Vec < Option < ExprOrSpread > >::visit_mut_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<Option<ExprOrSpread>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
+        <Vec<Option<ExprOrSpread>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Option < Pat > >`.\n\nBy default, this method calls [`Vec \
-             < Option < Pat > >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < Option < Pat > >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_opt_vec_pats(
-        &mut self,
-        node: &mut Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<Option<Pat>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
+        <Vec<Option<Pat>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Param`.\n\nBy default, this method calls \
-             [`Param::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Param::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
-        <Param as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_param(&mut self, node: &mut Param) {
+        <Param as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ParamOrTsParamProp`.\n\nBy default, this method calls \
-             [`ParamOrTsParamProp::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ParamOrTsParamProp::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(
-        &mut self,
-        node: &mut ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <ParamOrTsParamProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
+        <ParamOrTsParamProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ParamOrTsParamProp >`.\n\nBy default, this method calls \
-             [`Vec < ParamOrTsParamProp >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < ParamOrTsParamProp >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_param_or_ts_param_props(
-        &mut self,
-        node: &mut Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<ParamOrTsParamProp> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
+        <Vec<ParamOrTsParamProp> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Param >`.\n\nBy default, this method calls [`Vec < Param \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
-        <Vec<Param> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
+        <Vec<Param> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ParenExpr`.\n\nBy default, this method calls \
-             [`ParenExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ParenExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
-        <ParenExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
+        <ParenExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Pat`.\n\nBy default, this method calls \
-             [`Pat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Pat::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
-        <Pat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_pat(&mut self, node: &mut Pat) {
+        <Pat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Pat >`.\n\nBy default, this method calls [`Vec < Pat \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
-        <Vec<Pat> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
+        <Vec<Pat> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateMethod`.\n\nBy default, this method calls \
-             [`PrivateMethod::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PrivateMethod::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
-        <PrivateMethod as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
+        <PrivateMethod as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateName`.\n\nBy default, this method calls \
-             [`PrivateName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PrivateName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
-        <PrivateName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
+        <PrivateName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateProp`.\n\nBy default, this method calls \
-             [`PrivateProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PrivateProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
-        <PrivateProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
+        <PrivateProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Program`.\n\nBy default, this method calls \
-             [`Program::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Program::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
-        <Program as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_program(&mut self, node: &mut Program) {
+        <Program as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Prop`.\n\nBy default, this method calls \
-             [`Prop::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Prop::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
-        <Prop as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_prop(&mut self, node: &mut Prop) {
+        <Prop as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PropName`.\n\nBy default, this method calls \
-             [`PropName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`PropName::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
-        <PropName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
+        <PropName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `PropOrSpread`.\n\nBy default, this method calls \
-             [`PropOrSpread::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`PropOrSpread::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
-        <PropOrSpread as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
+        <PropOrSpread as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             PropOrSpread >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             PropOrSpread >::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_prop_or_spreads(
-        &mut self,
-        node: &mut Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<PropOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
+        <Vec<PropOrSpread> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
-             [`Regex::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Regex::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
-        <Regex as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_regex(&mut self, node: &mut Regex) {
+        <Regex as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `RestPat`.\n\nBy default, this method calls \
-             [`RestPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`RestPat::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
-        <RestPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
+        <RestPat as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ReturnStmt`.\n\nBy default, this method calls \
-             [`ReturnStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ReturnStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
-        <ReturnStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
+        <ReturnStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Script`.\n\nBy default, this method calls \
-             [`Script::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Script::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
-        <Script as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_script(&mut self, node: &mut Script) {
+        <Script as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SeqExpr`.\n\nBy default, this method calls \
-             [`SeqExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SeqExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
-        <SeqExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
+        <SeqExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SetterProp`.\n\nBy default, this method calls \
-             [`SetterProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SetterProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
-        <SetterProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
+        <SetterProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SimpleAssignTarget`.\n\nBy default, this method calls \
-             [`SimpleAssignTarget::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`SimpleAssignTarget::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_simple_assign_target(
-        &mut self,
-        node: &mut SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SimpleAssignTarget as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
+        <SimpleAssignTarget as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`swc_common :: Span::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
-        <swc_common::Span as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+        <swc_common::Span as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SpreadElement`.\n\nBy default, this method calls \
-             [`SpreadElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SpreadElement::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
-        <SpreadElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
+        <SpreadElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `StaticBlock`.\n\nBy default, this method calls \
-             [`StaticBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`StaticBlock::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
-        <StaticBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
+        <StaticBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Stmt`.\n\nBy default, this method calls \
-             [`Stmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Stmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
-        <Stmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
+        <Stmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Stmt >`.\n\nBy default, this method calls [`Vec < Stmt \
-             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
-        <Vec<Stmt> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
+        <Vec<Stmt> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Str::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
-        <Str as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_str(&mut self, node: &mut Str) {
+        <Str as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Super`.\n\nBy default, this method calls \
-             [`Super::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Super::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
-        <Super as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_super(&mut self, node: &mut Super) {
+        <Super as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SuperProp`.\n\nBy default, this method calls \
-             [`SuperProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SuperProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
-        <SuperProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
+        <SuperProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SuperPropExpr`.\n\nBy default, this method calls \
-             [`SuperPropExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SuperPropExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_super_prop_expr(
-        &mut self,
-        node: &mut SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <SuperPropExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
+        <SuperPropExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SwitchCase`.\n\nBy default, this method calls \
-             [`SwitchCase::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SwitchCase::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
-        <SwitchCase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
+        <SwitchCase as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SwitchCase >`.\n\nBy default, this method calls [`Vec < \
-             SwitchCase >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             SwitchCase >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
-        <Vec<SwitchCase> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
+        <Vec<SwitchCase> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `SwitchStmt`.\n\nBy default, this method calls \
-             [`SwitchStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SwitchStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
-        <SwitchStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
+        <SwitchStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_common :: SyntaxContext`.\n\nBy default, this method calls \
-             [`swc_common :: SyntaxContext::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`swc_common :: SyntaxContext::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_syntax_context(
-        &mut self,
-        node: &mut swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <swc_common::SyntaxContext as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
+        <swc_common::SyntaxContext as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TaggedTpl`.\n\nBy default, this method calls \
-             [`TaggedTpl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TaggedTpl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
-        <TaggedTpl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
+        <TaggedTpl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ThisExpr`.\n\nBy default, this method calls \
-             [`ThisExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ThisExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
-        <ThisExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
+        <ThisExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `ThrowStmt`.\n\nBy default, this method calls \
-             [`ThrowStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ThrowStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
-        <ThrowStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
+        <ThrowStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Tpl`.\n\nBy default, this method calls \
-             [`Tpl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Tpl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
-        <Tpl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
+    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
+        <Tpl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TplElement`.\n\nBy default, this method calls \
-             [`TplElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TplElement::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
-        <TplElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
+        <TplElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TplElement >`.\n\nBy default, this method calls [`Vec < \
-             TplElement >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             TplElement >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
-        <Vec<TplElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
+        <Vec<TplElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TruePlusMinus`.\n\nBy default, this method calls \
-             [`TruePlusMinus::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TruePlusMinus::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_true_plus_minus(
-        &mut self,
-        node: &mut TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TruePlusMinus as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
+        <TruePlusMinus as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TryStmt`.\n\nBy default, this method calls \
-             [`TryStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TryStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
-        <TryStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
+        <TryStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsArrayType`.\n\nBy default, this method calls \
-             [`TsArrayType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsArrayType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
-        <TsArrayType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
+        <TsArrayType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsAsExpr`.\n\nBy default, this method calls \
-             [`TsAsExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsAsExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
-        <TsAsExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
+        <TsAsExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsCallSignatureDecl`.\n\nBy default, this method calls \
-             [`TsCallSignatureDecl::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsCallSignatureDecl::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_call_signature_decl(
-        &mut self,
-        node: &mut TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsCallSignatureDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
+        <TsCallSignatureDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConditionalType`.\n\nBy default, this method calls \
-             [`TsConditionalType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsConditionalType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_conditional_type(
-        &mut self,
-        node: &mut TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsConditionalType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
+        <TsConditionalType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstAssertion`.\n\nBy default, this method calls \
-             [`TsConstAssertion::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsConstAssertion::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_const_assertion(
-        &mut self,
-        node: &mut TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsConstAssertion as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
+        <TsConstAssertion as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstructSignatureDecl`.\n\nBy default, this method calls \
-             [`TsConstructSignatureDecl::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`TsConstructSignatureDecl::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(
-        &mut self,
-        node: &mut TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsConstructSignatureDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
+        <TsConstructSignatureDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstructorType`.\n\nBy default, this method calls \
-             [`TsConstructorType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsConstructorType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_constructor_type(
-        &mut self,
-        node: &mut TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsConstructorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
+        <TsConstructorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEntityName`.\n\nBy default, this method calls \
-             [`TsEntityName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsEntityName::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
-        <TsEntityName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
+        <TsEntityName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumDecl`.\n\nBy default, this method calls \
-             [`TsEnumDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsEnumDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
-        <TsEnumDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
+        <TsEnumDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumMember`.\n\nBy default, this method calls \
-             [`TsEnumMember::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsEnumMember::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
-        <TsEnumMember as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
+        <TsEnumMember as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumMemberId`.\n\nBy default, this method calls \
-             [`TsEnumMemberId::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsEnumMemberId::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_enum_member_id(
-        &mut self,
-        node: &mut TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsEnumMemberId as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
+        <TsEnumMemberId as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsEnumMember >`.\n\nBy default, this method calls [`Vec < \
-             TsEnumMember >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             TsEnumMember >::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_enum_members(
-        &mut self,
-        node: &mut Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<TsEnumMember> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
+        <Vec<TsEnumMember> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExportAssignment`.\n\nBy default, this method calls \
-             [`TsExportAssignment::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsExportAssignment::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_export_assignment(
-        &mut self,
-        node: &mut TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsExportAssignment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
+        <TsExportAssignment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExprWithTypeArgs`.\n\nBy default, this method calls \
-             [`TsExprWithTypeArgs::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsExprWithTypeArgs::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(
-        &mut self,
-        node: &mut TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsExprWithTypeArgs as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
+        <TsExprWithTypeArgs as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsExprWithTypeArgs >`.\n\nBy default, this method calls \
-             [`Vec < TsExprWithTypeArgs >::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Vec < TsExprWithTypeArgs >::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(
-        &mut self,
-        node: &mut Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<TsExprWithTypeArgs> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
+        <Vec<TsExprWithTypeArgs> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExternalModuleRef`.\n\nBy default, this method calls \
-             [`TsExternalModuleRef::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsExternalModuleRef::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_external_module_ref(
-        &mut self,
-        node: &mut TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsExternalModuleRef as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
+        <TsExternalModuleRef as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnOrConstructorType`.\n\nBy default, this method calls \
-             [`TsFnOrConstructorType::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsFnOrConstructorType::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(
-        &mut self,
-        node: &mut TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsFnOrConstructorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
+        <TsFnOrConstructorType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnParam`.\n\nBy default, this method calls \
-             [`TsFnParam::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsFnParam::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
-        <TsFnParam as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
+        <TsFnParam as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsFnParam >`.\n\nBy default, this method calls [`Vec < \
-             TsFnParam >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             TsFnParam >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
-        <Vec<TsFnParam> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
+        <Vec<TsFnParam> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnType`.\n\nBy default, this method calls \
-             [`TsFnType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsFnType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
-        <TsFnType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
+        <TsFnType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsGetterSignature`.\n\nBy default, this method calls \
-             [`TsGetterSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsGetterSignature::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_getter_signature(
-        &mut self,
-        node: &mut TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsGetterSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
+        <TsGetterSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsImportEqualsDecl`.\n\nBy default, this method calls \
-             [`TsImportEqualsDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsImportEqualsDecl::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_import_equals_decl(
-        &mut self,
-        node: &mut TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsImportEqualsDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
+        <TsImportEqualsDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsImportType`.\n\nBy default, this method calls \
-             [`TsImportType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsImportType::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
-        <TsImportType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
+        <TsImportType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIndexSignature`.\n\nBy default, this method calls \
-             [`TsIndexSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsIndexSignature::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_index_signature(
-        &mut self,
-        node: &mut TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsIndexSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
+        <TsIndexSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIndexedAccessType`.\n\nBy default, this method calls \
-             [`TsIndexedAccessType::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsIndexedAccessType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_indexed_access_type(
-        &mut self,
-        node: &mut TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsIndexedAccessType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
+        <TsIndexedAccessType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInferType`.\n\nBy default, this method calls \
-             [`TsInferType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsInferType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
-        <TsInferType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
+        <TsInferType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInstantiation`.\n\nBy default, this method calls \
-             [`TsInstantiation::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsInstantiation::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_instantiation(
-        &mut self,
-        node: &mut TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsInstantiation as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
+        <TsInstantiation as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInterfaceBody`.\n\nBy default, this method calls \
-             [`TsInterfaceBody::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsInterfaceBody::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_interface_body(
-        &mut self,
-        node: &mut TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsInterfaceBody as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
+        <TsInterfaceBody as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInterfaceDecl`.\n\nBy default, this method calls \
-             [`TsInterfaceDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsInterfaceDecl::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_interface_decl(
-        &mut self,
-        node: &mut TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsInterfaceDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
+        <TsInterfaceDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIntersectionType`.\n\nBy default, this method calls \
-             [`TsIntersectionType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsIntersectionType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_intersection_type(
-        &mut self,
-        node: &mut TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsIntersectionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
+        <TsIntersectionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsKeywordType`.\n\nBy default, this method calls \
-             [`TsKeywordType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsKeywordType::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_keyword_type(
-        &mut self,
-        node: &mut TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsKeywordType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
+        <TsKeywordType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsKeywordTypeKind`.\n\nBy default, this method calls \
-             [`TsKeywordTypeKind::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsKeywordTypeKind::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(
-        &mut self,
-        node: &mut TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsKeywordTypeKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
+        <TsKeywordTypeKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsLit`.\n\nBy default, this method calls \
-             [`TsLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
-        <TsLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
+        <TsLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsLitType`.\n\nBy default, this method calls \
-             [`TsLitType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsLitType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
-        <TsLitType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
+        <TsLitType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsMappedType`.\n\nBy default, this method calls \
-             [`TsMappedType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsMappedType::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
-        <TsMappedType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
+        <TsMappedType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsMethodSignature`.\n\nBy default, this method calls \
-             [`TsMethodSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsMethodSignature::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_method_signature(
-        &mut self,
-        node: &mut TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsMethodSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
+        <TsMethodSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleBlock`.\n\nBy default, this method calls \
-             [`TsModuleBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsModuleBlock::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_module_block(
-        &mut self,
-        node: &mut TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsModuleBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
+        <TsModuleBlock as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleDecl`.\n\nBy default, this method calls \
-             [`TsModuleDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsModuleDecl::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
-        <TsModuleDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
+        <TsModuleDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleName`.\n\nBy default, this method calls \
-             [`TsModuleName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsModuleName::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
-        <TsModuleName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
+        <TsModuleName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleRef`.\n\nBy default, this method calls \
-             [`TsModuleRef::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsModuleRef::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
-        <TsModuleRef as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
+        <TsModuleRef as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceBody`.\n\nBy default, this method calls \
-             [`TsNamespaceBody::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsNamespaceBody::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_namespace_body(
-        &mut self,
-        node: &mut TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsNamespaceBody as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
+        <TsNamespaceBody as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsNamespaceDecl::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_namespace_decl(
-        &mut self,
-        node: &mut TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsNamespaceDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
+        <TsNamespaceDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceExportDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceExportDecl::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsNamespaceExportDecl::visit_mut_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(
-        &mut self,
-        node: &mut TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsNamespaceExportDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
+        <TsNamespaceExportDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNonNullExpr`.\n\nBy default, this method calls \
-             [`TsNonNullExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsNonNullExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_non_null_expr(
-        &mut self,
-        node: &mut TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsNonNullExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
+        <TsNonNullExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsOptionalType`.\n\nBy default, this method calls \
-             [`TsOptionalType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsOptionalType::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_optional_type(
-        &mut self,
-        node: &mut TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsOptionalType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
+        <TsOptionalType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParamProp`.\n\nBy default, this method calls \
-             [`TsParamProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsParamProp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
-        <TsParamProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
+        <TsParamProp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParamPropParam`.\n\nBy default, this method calls \
-             [`TsParamPropParam::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsParamPropParam::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_param_prop_param(
-        &mut self,
-        node: &mut TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsParamPropParam as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
+        <TsParamPropParam as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParenthesizedType`.\n\nBy default, this method calls \
-             [`TsParenthesizedType::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsParenthesizedType::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_parenthesized_type(
-        &mut self,
-        node: &mut TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsParenthesizedType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
+        <TsParenthesizedType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsPropertySignature`.\n\nBy default, this method calls \
-             [`TsPropertySignature::visit_mut_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsPropertySignature::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_property_signature(
-        &mut self,
-        node: &mut TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsPropertySignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
+        <TsPropertySignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsQualifiedName`.\n\nBy default, this method calls \
-             [`TsQualifiedName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsQualifiedName::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_qualified_name(
-        &mut self,
-        node: &mut TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsQualifiedName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
+        <TsQualifiedName as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsRestType`.\n\nBy default, this method calls \
-             [`TsRestType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsRestType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
-        <TsRestType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
+        <TsRestType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsSatisfiesExpr`.\n\nBy default, this method calls \
-             [`TsSatisfiesExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsSatisfiesExpr::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_satisfies_expr(
-        &mut self,
-        node: &mut TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsSatisfiesExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
+        <TsSatisfiesExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsSetterSignature`.\n\nBy default, this method calls \
-             [`TsSetterSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsSetterSignature::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_setter_signature(
-        &mut self,
-        node: &mut TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsSetterSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
+        <TsSetterSignature as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsThisType`.\n\nBy default, this method calls \
-             [`TsThisType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsThisType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
-        <TsThisType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
+        <TsThisType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsThisTypeOrIdent`.\n\nBy default, this method calls \
-             [`TsThisTypeOrIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsThisTypeOrIdent::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(
-        &mut self,
-        node: &mut TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsThisTypeOrIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
+        <TsThisTypeOrIdent as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTplLitType`.\n\nBy default, this method calls \
-             [`TsTplLitType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsTplLitType::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
-        <TsTplLitType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
+        <TsTplLitType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTupleElement`.\n\nBy default, this method calls \
-             [`TsTupleElement::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTupleElement::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_tuple_element(
-        &mut self,
-        node: &mut TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTupleElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
+        <TsTupleElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTupleElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTupleElement >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < TsTupleElement >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_tuple_elements(
-        &mut self,
-        node: &mut Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<TsTupleElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
+        <Vec<TsTupleElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTupleType`.\n\nBy default, this method calls \
-             [`TsTupleType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsTupleType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
-        <TsTupleType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
+        <TsTupleType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsType`.\n\nBy default, this method calls \
-             [`TsType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
-        <TsType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
+        <TsType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAliasDecl`.\n\nBy default, this method calls \
-             [`TsTypeAliasDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypeAliasDecl::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_alias_decl(
-        &mut self,
-        node: &mut TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeAliasDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
+        <TsTypeAliasDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAnn`.\n\nBy default, this method calls \
-             [`TsTypeAnn::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeAnn::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
-        <TsTypeAnn as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
+        <TsTypeAnn as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAssertion`.\n\nBy default, this method calls \
-             [`TsTypeAssertion::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypeAssertion::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_assertion(
-        &mut self,
-        node: &mut TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeAssertion as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
+        <TsTypeAssertion as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeElement`.\n\nBy default, this method calls \
-             [`TsTypeElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsTypeElement::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_type_element(
-        &mut self,
-        node: &mut TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
+        <TsTypeElement as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTypeElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTypeElement >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < TsTypeElement >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_elements(
-        &mut self,
-        node: &mut Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<TsTypeElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
+        <Vec<TsTypeElement> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeLit`.\n\nBy default, this method calls \
-             [`TsTypeLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeLit::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
-        <TsTypeLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
+        <TsTypeLit as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeOperator`.\n\nBy default, this method calls \
-             [`TsTypeOperator::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypeOperator::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_ts_type_operator(
-        &mut self,
-        node: &mut TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
+        <TsTypeOperator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeOperatorOp`.\n\nBy default, this method calls \
-             [`TsTypeOperatorOp::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypeOperatorOp::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_operator_op(
-        &mut self,
-        node: &mut TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeOperatorOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
+        <TsTypeOperatorOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParam`.\n\nBy default, this method calls \
-             [`TsTypeParam::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsTypeParam::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
-        <TsTypeParam as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
+        <TsTypeParam as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParamDecl`.\n\nBy default, this method calls \
-             [`TsTypeParamDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypeParamDecl::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_param_decl(
-        &mut self,
-        node: &mut TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeParamDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
+        <TsTypeParamDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParamInstantiation`.\n\nBy default, this method calls \
-             [`TsTypeParamInstantiation::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`TsTypeParamInstantiation::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(
-        &mut self,
-        node: &mut TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeParamInstantiation as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
+        <TsTypeParamInstantiation as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTypeParam >`.\n\nBy default, this method calls [`Vec < \
-             TsTypeParam >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             TsTypeParam >::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_type_params(
-        &mut self,
-        node: &mut Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<TsTypeParam> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
+        <Vec<TsTypeParam> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypePredicate`.\n\nBy default, this method calls \
-             [`TsTypePredicate::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypePredicate::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_predicate(
-        &mut self,
-        node: &mut TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypePredicate as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
+        <TsTypePredicate as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeQuery`.\n\nBy default, this method calls \
-             [`TsTypeQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsTypeQuery::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
-        <TsTypeQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
+        <TsTypeQuery as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeQueryExpr`.\n\nBy default, this method calls \
-             [`TsTypeQueryExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsTypeQueryExpr::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_type_query_expr(
-        &mut self,
-        node: &mut TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsTypeQueryExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
+        <TsTypeQueryExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeRef`.\n\nBy default, this method calls \
-             [`TsTypeRef::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeRef::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
-        <TsTypeRef as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
+        <TsTypeRef as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Box < TsType > >`.\n\nBy default, this method calls [`Vec \
-             < Box < TsType > >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < Box < TsType > >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
-        <Vec<Box<TsType>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
+        <Vec<Box<TsType>> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsUnionOrIntersectionType`.\n\nBy default, this method calls \
-             [`TsUnionOrIntersectionType::visit_mut_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`TsUnionOrIntersectionType::visit_mut_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(
-        &mut self,
-        node: &mut TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <TsUnionOrIntersectionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
+        <TsUnionOrIntersectionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsUnionType`.\n\nBy default, this method calls \
-             [`TsUnionType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsUnionType::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
-        <TsUnionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
+        <TsUnionType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnaryExpr`.\n\nBy default, this method calls \
-             [`UnaryExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UnaryExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
-        <UnaryExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
+        <UnaryExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnaryOp`.\n\nBy default, this method calls \
-             [`UnaryOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UnaryOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
-        <UnaryOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
+        <UnaryOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UpdateExpr`.\n\nBy default, this method calls \
-             [`UpdateExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UpdateExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
-        <UpdateExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
+        <UpdateExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UpdateOp`.\n\nBy default, this method calls \
-             [`UpdateOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UpdateOp::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
-        <UpdateOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
+        <UpdateOp as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `UsingDecl`.\n\nBy default, this method calls \
-             [`UsingDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`UsingDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
-        <UsingDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
+        <UsingDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDecl`.\n\nBy default, this method calls \
-             [`VarDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`VarDecl::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
-        <VarDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
+        <VarDecl as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclKind`.\n\nBy default, this method calls \
-             [`VarDeclKind::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`VarDeclKind::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
-        <VarDeclKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
+        <VarDeclKind as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclOrExpr`.\n\nBy default, this method calls \
-             [`VarDeclOrExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`VarDeclOrExpr::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_var_decl_or_expr(
-        &mut self,
-        node: &mut VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <VarDeclOrExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
+        <VarDeclOrExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclarator`.\n\nBy default, this method calls \
-             [`VarDeclarator::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`VarDeclarator::visit_mut_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
-        <VarDeclarator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
+        <VarDeclarator as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < VarDeclarator >`.\n\nBy default, this method calls [`Vec \
-             < VarDeclarator >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             < VarDeclarator >::visit_mut_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_mut_var_declarators(
-        &mut self,
-        node: &mut Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <Vec<VarDeclarator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
+        <Vec<VarDeclarator> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `WhileStmt`.\n\nBy default, this method calls \
-             [`WhileStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`WhileStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
-        <WhileStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
+        <WhileStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `WithStmt`.\n\nBy default, this method calls \
-             [`WithStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`WithStmt::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
-        <WithStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
+        <WithStmt as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `YieldExpr`.\n\nBy default, this method calls \
-             [`YieldExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`YieldExpr::visit_mut_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
-        <YieldExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
+        <YieldExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitMutAstPath for &mut V
+impl<V> VisitMut for &mut V
 where
-    V: ?Sized + VisitMutAstPath,
+    V: ?Sized + VisitMut,
 {
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_accessibility(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_array_lit(&mut **self, node, __ast_path)
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
+        <V as VisitMut>::visit_mut_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_array_pat(&mut **self, node, __ast_path)
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
+        <V as VisitMut>::visit_mut_array_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_arrow_expr(&mut **self, node, __ast_path)
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
+        <V as VisitMut>::visit_mut_array_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_expr(&mut **self, node, __ast_path)
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
+        <V as VisitMut>::visit_mut_arrow_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_op(&mut **self, node, __ast_path)
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
+        <V as VisitMut>::visit_mut_assign_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_pat(&mut **self, node, __ast_path)
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
+        <V as VisitMut>::visit_mut_assign_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(
-        &mut self,
-        node: &mut AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_assign_pat_prop(&mut **self, node, __ast_path)
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
+        <V as VisitMut>::visit_mut_assign_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_prop(&mut **self, node, __ast_path)
+    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
+        <V as VisitMut>::visit_mut_assign_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_target(&mut **self, node, __ast_path)
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
+        <V as VisitMut>::visit_mut_assign_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(
-        &mut self,
-        node: &mut AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_assign_target_pat(&mut **self, node, __ast_path)
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
+        <V as VisitMut>::visit_mut_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
+    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
+        <V as VisitMut>::visit_mut_assign_target_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_auto_accessor(&mut **self, node, __ast_path)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+        <V as VisitMut>::visit_mut_atom(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_await_expr(&mut **self, node, __ast_path)
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
+        <V as VisitMut>::visit_mut_auto_accessor(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_big_int(&mut **self, node, __ast_path)
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
+        <V as VisitMut>::visit_mut_await_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_big_int_value(&mut **self, node, __ast_path)
+    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
+        <V as VisitMut>::visit_mut_big_int(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bin_expr(&mut **self, node, __ast_path)
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
+        <V as VisitMut>::visit_mut_big_int_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_binary_op(&mut **self, node, __ast_path)
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
+        <V as VisitMut>::visit_mut_bin_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_binding_ident(&mut **self, node, __ast_path)
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
+        <V as VisitMut>::visit_mut_binary_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_block_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
+        <V as VisitMut>::visit_mut_binding_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(
-        &mut self,
-        node: &mut BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(&mut **self, node, __ast_path)
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
+        <V as VisitMut>::visit_mut_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bool(&mut **self, node, __ast_path)
+    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
+        <V as VisitMut>::visit_mut_block_stmt_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_break_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_bool(&mut self, node: &mut Bool) {
+        <V as VisitMut>::visit_mut_bool(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_call_expr(&mut **self, node, __ast_path)
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
+        <V as VisitMut>::visit_mut_break_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_callee(&mut **self, node, __ast_path)
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
+        <V as VisitMut>::visit_mut_call_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_catch_clause(&mut **self, node, __ast_path)
+    fn visit_mut_callee(&mut self, node: &mut Callee) {
+        <V as VisitMut>::visit_mut_callee(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class(&mut **self, node, __ast_path)
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
+        <V as VisitMut>::visit_mut_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_decl(&mut **self, node, __ast_path)
+    fn visit_mut_class(&mut self, node: &mut Class) {
+        <V as VisitMut>::visit_mut_class(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_expr(&mut **self, node, __ast_path)
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
+        <V as VisitMut>::visit_mut_class_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_member(&mut **self, node, __ast_path)
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
+        <V as VisitMut>::visit_mut_class_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_members(
-        &mut self,
-        node: &mut Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_class_members(&mut **self, node, __ast_path)
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
+        <V as VisitMut>::visit_mut_class_member(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_method(&mut **self, node, __ast_path)
+    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
+        <V as VisitMut>::visit_mut_class_members(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_prop(&mut **self, node, __ast_path)
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
+        <V as VisitMut>::visit_mut_class_method(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(
-        &mut self,
-        node: &mut ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_computed_prop_name(&mut **self, node, __ast_path)
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
+        <V as VisitMut>::visit_mut_class_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_cond_expr(&mut **self, node, __ast_path)
+    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
+        <V as VisitMut>::visit_mut_computed_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_constructor(&mut **self, node, __ast_path)
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
+        <V as VisitMut>::visit_mut_cond_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_continue_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
+        <V as VisitMut>::visit_mut_constructor(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_debugger_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
+        <V as VisitMut>::visit_mut_continue_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decl(&mut **self, node, __ast_path)
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
+        <V as VisitMut>::visit_mut_debugger_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decorator(&mut **self, node, __ast_path)
+    fn visit_mut_decl(&mut self, node: &mut Decl) {
+        <V as VisitMut>::visit_mut_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decorators(&mut **self, node, __ast_path)
+    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
+        <V as VisitMut>::visit_mut_decorator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_default_decl(&mut **self, node, __ast_path)
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
+        <V as VisitMut>::visit_mut_decorators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_do_while_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
+        <V as VisitMut>::visit_mut_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_empty_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
+        <V as VisitMut>::visit_mut_do_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_es_version(&mut **self, node, __ast_path)
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
+        <V as VisitMut>::visit_mut_empty_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_all(&mut **self, node, __ast_path)
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
+        <V as VisitMut>::visit_mut_es_version(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_decl(&mut **self, node, __ast_path)
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
+        <V as VisitMut>::visit_mut_export_all(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(
-        &mut self,
-        node: &mut ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_default_decl(&mut **self, node, __ast_path)
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
+        <V as VisitMut>::visit_mut_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(
-        &mut self,
-        node: &mut ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_default_expr(&mut **self, node, __ast_path)
+    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
+        <V as VisitMut>::visit_mut_export_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(
-        &mut self,
-        node: &mut ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_default_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
+        <V as VisitMut>::visit_mut_export_default_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(
-        &mut self,
-        node: &mut ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_named_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
+        <V as VisitMut>::visit_mut_export_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(
-        &mut self,
-        node: &mut ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
+        <V as VisitMut>::visit_mut_export_named_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_specifier(
-        &mut self,
-        node: &mut ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
+        <V as VisitMut>::visit_mut_export_namespace_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(
-        &mut self,
-        node: &mut Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_specifiers(&mut **self, node, __ast_path)
+    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
+        <V as VisitMut>::visit_mut_export_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr(&mut **self, node, __ast_path)
+    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
+        <V as VisitMut>::visit_mut_export_specifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_expr(&mut self, node: &mut Expr) {
+        <V as VisitMut>::visit_mut_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_expr_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
+        <V as VisitMut>::visit_mut_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
+        <V as VisitMut>::visit_mut_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_exprs(&mut **self, node, __ast_path)
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
+        <V as VisitMut>::visit_mut_expr_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_fn_decl(&mut **self, node, __ast_path)
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
+        <V as VisitMut>::visit_mut_exprs(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_fn_expr(&mut **self, node, __ast_path)
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
+        <V as VisitMut>::visit_mut_fn_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_head(&mut **self, node, __ast_path)
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
+        <V as VisitMut>::visit_mut_fn_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_in_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
+        <V as VisitMut>::visit_mut_for_head(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_of_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
+        <V as VisitMut>::visit_mut_for_in_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
+        <V as VisitMut>::visit_mut_for_of_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
+        <V as VisitMut>::visit_mut_for_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_getter_prop(&mut **self, node, __ast_path)
+    fn visit_mut_function(&mut self, node: &mut Function) {
+        <V as VisitMut>::visit_mut_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
+        <V as VisitMut>::visit_mut_getter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident_name(&mut **self, node, __ast_path)
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
+        <V as VisitMut>::visit_mut_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_if_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
+        <V as VisitMut>::visit_mut_ident_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import(&mut **self, node, __ast_path)
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
+        <V as VisitMut>::visit_mut_if_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_decl(&mut **self, node, __ast_path)
+    fn visit_mut_import(&mut self, node: &mut Import) {
+        <V as VisitMut>::visit_mut_import(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(
-        &mut self,
-        node: &mut ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_default_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
+        <V as VisitMut>::visit_mut_import_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(
-        &mut self,
-        node: &mut ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_named_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
+        <V as VisitMut>::visit_mut_import_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_phase(&mut **self, node, __ast_path)
+    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
+        <V as VisitMut>::visit_mut_import_named_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_specifier(
-        &mut self,
-        node: &mut ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
+        <V as VisitMut>::visit_mut_import_phase(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(
-        &mut self,
-        node: &mut Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_specifiers(&mut **self, node, __ast_path)
+    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
+        <V as VisitMut>::visit_mut_import_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(
-        &mut self,
-        node: &mut ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
+        <V as VisitMut>::visit_mut_import_specifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_with(&mut **self, node, __ast_path)
+    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
+        <V as VisitMut>::visit_mut_import_star_as_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_with_item(
-        &mut self,
-        node: &mut ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_with_item(&mut **self, node, __ast_path)
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
+        <V as VisitMut>::visit_mut_import_with(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_with_items(
-        &mut self,
-        node: &mut Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_with_items(&mut **self, node, __ast_path)
+    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
+        <V as VisitMut>::visit_mut_import_with_item(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_invalid(&mut **self, node, __ast_path)
+    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
+        <V as VisitMut>::visit_mut_import_with_items(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr(&mut **self, node, __ast_path)
+    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
+        <V as VisitMut>::visit_mut_invalid(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_name(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
+        <V as VisitMut>::visit_mut_jsx_attr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(
-        &mut self,
-        node: &mut JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
+        <V as VisitMut>::visit_mut_jsx_attr_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(
-        &mut self,
-        node: &mut Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
+        <V as VisitMut>::visit_mut_jsx_attr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_value(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
+        <V as VisitMut>::visit_mut_jsx_attr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(
-        &mut self,
-        node: &mut JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_closing_element(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
+        <V as VisitMut>::visit_mut_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(
-        &mut self,
-        node: &mut JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
+        <V as VisitMut>::visit_mut_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
+        <V as VisitMut>::visit_mut_jsx_closing_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(
-        &mut self,
-        node: &mut JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_child(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
+        <V as VisitMut>::visit_mut_jsx_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(
-        &mut self,
-        node: &mut Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_childs(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
+        <V as VisitMut>::visit_mut_jsx_element_child(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(
-        &mut self,
-        node: &mut JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_name(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
+        <V as VisitMut>::visit_mut_jsx_element_childs(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
+        <V as VisitMut>::visit_mut_jsx_element_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_expr(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
+        <V as VisitMut>::visit_mut_jsx_empty_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(
-        &mut self,
-        node: &mut JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_expr_container(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
+        <V as VisitMut>::visit_mut_jsx_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_fragment(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
+        <V as VisitMut>::visit_mut_jsx_expr_container(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(
-        &mut self,
-        node: &mut JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_member_expr(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
+        <V as VisitMut>::visit_mut_jsx_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(
-        &mut self,
-        node: &mut JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
+        <V as VisitMut>::visit_mut_jsx_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_object(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
+        <V as VisitMut>::visit_mut_jsx_namespaced_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(
-        &mut self,
-        node: &mut JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_opening_element(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
+        <V as VisitMut>::visit_mut_jsx_object(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(
-        &mut self,
-        node: &mut JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
+        <V as VisitMut>::visit_mut_jsx_opening_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(
-        &mut self,
-        node: &mut JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_spread_child(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
+        <V as VisitMut>::visit_mut_jsx_opening_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_text(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
+        <V as VisitMut>::visit_mut_jsx_spread_child(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_key(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
+        <V as VisitMut>::visit_mut_jsx_text(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(
-        &mut self,
-        node: &mut KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(&mut **self, node, __ast_path)
+    fn visit_mut_key(&mut self, node: &mut Key) {
+        <V as VisitMut>::visit_mut_key(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_key_value_prop(&mut **self, node, __ast_path)
+    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
+        <V as VisitMut>::visit_mut_key_value_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_labeled_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
+        <V as VisitMut>::visit_mut_key_value_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_lit(&mut **self, node, __ast_path)
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
+        <V as VisitMut>::visit_mut_labeled_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_member_expr(&mut **self, node, __ast_path)
+    fn visit_mut_lit(&mut self, node: &mut Lit) {
+        <V as VisitMut>::visit_mut_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_member_prop(&mut **self, node, __ast_path)
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
+        <V as VisitMut>::visit_mut_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_meta_prop_expr(&mut **self, node, __ast_path)
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
+        <V as VisitMut>::visit_mut_member_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_meta_prop_kind(&mut **self, node, __ast_path)
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
+        <V as VisitMut>::visit_mut_meta_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_method_kind(&mut **self, node, __ast_path)
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
+        <V as VisitMut>::visit_mut_meta_prop_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_method_prop(&mut **self, node, __ast_path)
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
+        <V as VisitMut>::visit_mut_method_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module(&mut **self, node, __ast_path)
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
+        <V as VisitMut>::visit_mut_method_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_decl(&mut **self, node, __ast_path)
+    fn visit_mut_module(&mut self, node: &mut Module) {
+        <V as VisitMut>::visit_mut_module(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_export_name(
-        &mut self,
-        node: &mut ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_module_export_name(&mut **self, node, __ast_path)
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
+        <V as VisitMut>::visit_mut_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_item(&mut **self, node, __ast_path)
+    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
+        <V as VisitMut>::visit_mut_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_items(&mut **self, node, __ast_path)
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
+        <V as VisitMut>::visit_mut_module_item(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_named_export(&mut **self, node, __ast_path)
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
+        <V as VisitMut>::visit_mut_module_items(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_new_expr(&mut **self, node, __ast_path)
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
+        <V as VisitMut>::visit_mut_named_export(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_null(&mut **self, node, __ast_path)
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
+        <V as VisitMut>::visit_mut_new_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
+    fn visit_mut_null(&mut self, node: &mut Null) {
+        <V as VisitMut>::visit_mut_null(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_lit(&mut **self, node, __ast_path)
+    fn visit_mut_number(&mut self, node: &mut Number) {
+        <V as VisitMut>::visit_mut_number(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_pat(&mut **self, node, __ast_path)
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
+        <V as VisitMut>::visit_mut_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(
-        &mut self,
-        node: &mut ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_object_pat_prop(&mut **self, node, __ast_path)
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
+        <V as VisitMut>::visit_mut_object_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(
-        &mut self,
-        node: &mut Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_object_pat_props(&mut **self, node, __ast_path)
+    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
+        <V as VisitMut>::visit_mut_object_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(
-        &mut self,
-        node: &mut Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_accessibility(&mut **self, node, __ast_path)
+    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
+        <V as VisitMut>::visit_mut_object_pat_props(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
+    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
+        <V as VisitMut>::visit_mut_opt_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_block_stmt(
-        &mut self,
-        node: &mut Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_block_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_call(&mut **self, node, __ast_path)
+    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
+        <V as VisitMut>::visit_mut_opt_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(
-        &mut self,
-        node: &mut Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_catch_clause(&mut **self, node, __ast_path)
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
+        <V as VisitMut>::visit_mut_opt_call(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_chain_base(&mut **self, node, __ast_path)
+    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
+        <V as VisitMut>::visit_mut_opt_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_chain_expr(&mut **self, node, __ast_path)
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
+        <V as VisitMut>::visit_mut_opt_chain_base(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr(&mut **self, node, __ast_path)
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
+        <V as VisitMut>::visit_mut_opt_chain_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(
-        &mut self,
-        node: &mut Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
+        <V as VisitMut>::visit_mut_opt_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(
-        &mut self,
-        node: &mut Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
+        <V as VisitMut>::visit_mut_opt_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
+    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
+        <V as VisitMut>::visit_mut_opt_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(
-        &mut self,
-        node: &mut Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(
-        &mut self,
-        node: &mut Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(&mut **self, node, __ast_path)
+    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
+        <V as VisitMut>::visit_mut_opt_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(
-        &mut self,
-        node: &mut Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_module_export_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
+        <V as VisitMut>::visit_mut_opt_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(
-        &mut self,
-        node: &mut Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_object_lit(&mut **self, node, __ast_path)
+    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
+        <V as VisitMut>::visit_mut_opt_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_pat(&mut **self, node, __ast_path)
+    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
+        <V as VisitMut>::visit_mut_opt_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_span(
-        &mut self,
-        node: &mut Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_span(&mut **self, node, __ast_path)
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
+        <V as VisitMut>::visit_mut_opt_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
+        <V as VisitMut>::visit_mut_opt_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_str(&mut **self, node, __ast_path)
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
+        <V as VisitMut>::visit_mut_opt_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(
-        &mut self,
-        node: &mut Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(&mut **self, node, __ast_path)
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
+        <V as VisitMut>::visit_mut_opt_str(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(
-        &mut self,
-        node: &mut Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
+        <V as VisitMut>::visit_mut_opt_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(
-        &mut self,
-        node: &mut Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
+        <V as VisitMut>::visit_mut_opt_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(
-        &mut self,
-        node: &mut Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
+        <V as VisitMut>::visit_mut_opt_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(
-        &mut self,
-        node: &mut Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
+        <V as VisitMut>::visit_mut_opt_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(
-        &mut self,
-        node: &mut Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
+        <V as VisitMut>::visit_mut_opt_ts_type_ann(&mut **self, node)
+    }
+
+    #[inline]
+    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
+        <V as VisitMut>::visit_mut_opt_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
     fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
         node: &mut Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+        <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(
-        &mut self,
-        node: &mut Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
+        <V as VisitMut>::visit_mut_opt_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
+        <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(
-        &mut self,
-        node: &mut Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_vec_pats(&mut **self, node, __ast_path)
+    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
+        <V as VisitMut>::visit_mut_opt_vec_pats(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_param(&mut **self, node, __ast_path)
+    fn visit_mut_param(&mut self, node: &mut Param) {
+        <V as VisitMut>::visit_mut_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(
-        &mut self,
-        node: &mut ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(&mut **self, node, __ast_path)
+    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
+        <V as VisitMut>::visit_mut_param_or_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(
-        &mut self,
-        node: &mut Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(&mut **self, node, __ast_path)
+    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
+        <V as VisitMut>::visit_mut_param_or_ts_param_props(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_params(&mut **self, node, __ast_path)
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
+        <V as VisitMut>::visit_mut_params(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_paren_expr(&mut **self, node, __ast_path)
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
+        <V as VisitMut>::visit_mut_paren_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pat(&mut **self, node, __ast_path)
+    fn visit_mut_pat(&mut self, node: &mut Pat) {
+        <V as VisitMut>::visit_mut_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pats(&mut **self, node, __ast_path)
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
+        <V as VisitMut>::visit_mut_pats(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_method(&mut **self, node, __ast_path)
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
+        <V as VisitMut>::visit_mut_private_method(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_name(&mut **self, node, __ast_path)
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
+        <V as VisitMut>::visit_mut_private_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_prop(&mut **self, node, __ast_path)
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
+        <V as VisitMut>::visit_mut_private_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_program(&mut **self, node, __ast_path)
+    fn visit_mut_program(&mut self, node: &mut Program) {
+        <V as VisitMut>::visit_mut_program(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop(&mut **self, node, __ast_path)
+    fn visit_mut_prop(&mut self, node: &mut Prop) {
+        <V as VisitMut>::visit_mut_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop_name(&mut **self, node, __ast_path)
+    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
+        <V as VisitMut>::visit_mut_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
+        <V as VisitMut>::visit_mut_prop_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(
-        &mut self,
-        node: &mut Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_prop_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
+        <V as VisitMut>::visit_mut_prop_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_regex(&mut **self, node, __ast_path)
+    fn visit_mut_regex(&mut self, node: &mut Regex) {
+        <V as VisitMut>::visit_mut_regex(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rest_pat(&mut **self, node, __ast_path)
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
+        <V as VisitMut>::visit_mut_rest_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_return_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
+        <V as VisitMut>::visit_mut_return_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_script(&mut **self, node, __ast_path)
+    fn visit_mut_script(&mut self, node: &mut Script) {
+        <V as VisitMut>::visit_mut_script(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_seq_expr(&mut **self, node, __ast_path)
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
+        <V as VisitMut>::visit_mut_seq_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_setter_prop(&mut **self, node, __ast_path)
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
+        <V as VisitMut>::visit_mut_setter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(
-        &mut self,
-        node: &mut SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_simple_assign_target(&mut **self, node, __ast_path)
+    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
+        <V as VisitMut>::visit_mut_simple_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+        <V as VisitMut>::visit_mut_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_spread_element(&mut **self, node, __ast_path)
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
+        <V as VisitMut>::visit_mut_spread_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_static_block(&mut **self, node, __ast_path)
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
+        <V as VisitMut>::visit_mut_static_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
+        <V as VisitMut>::visit_mut_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stmts(&mut **self, node, __ast_path)
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
+        <V as VisitMut>::visit_mut_stmts(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
+    fn visit_mut_str(&mut self, node: &mut Str) {
+        <V as VisitMut>::visit_mut_str(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_super(&mut **self, node, __ast_path)
+    fn visit_mut_super(&mut self, node: &mut Super) {
+        <V as VisitMut>::visit_mut_super(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_super_prop(&mut **self, node, __ast_path)
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
+        <V as VisitMut>::visit_mut_super_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(
-        &mut self,
-        node: &mut SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_super_prop_expr(&mut **self, node, __ast_path)
+    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
+        <V as VisitMut>::visit_mut_super_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_case(&mut **self, node, __ast_path)
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
+        <V as VisitMut>::visit_mut_switch_case(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_cases(&mut **self, node, __ast_path)
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
+        <V as VisitMut>::visit_mut_switch_cases(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
+        <V as VisitMut>::visit_mut_switch_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_syntax_context(
-        &mut self,
-        node: &mut swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_syntax_context(&mut **self, node, __ast_path)
+    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
+        <V as VisitMut>::visit_mut_syntax_context(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tagged_tpl(&mut **self, node, __ast_path)
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
+        <V as VisitMut>::visit_mut_tagged_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_this_expr(&mut **self, node, __ast_path)
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
+        <V as VisitMut>::visit_mut_this_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_throw_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
+        <V as VisitMut>::visit_mut_throw_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl(&mut **self, node, __ast_path)
+    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
+        <V as VisitMut>::visit_mut_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl_element(&mut **self, node, __ast_path)
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
+        <V as VisitMut>::visit_mut_tpl_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl_elements(&mut **self, node, __ast_path)
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
+        <V as VisitMut>::visit_mut_tpl_elements(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(
-        &mut self,
-        node: &mut TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_true_plus_minus(&mut **self, node, __ast_path)
+    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
+        <V as VisitMut>::visit_mut_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_try_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
+        <V as VisitMut>::visit_mut_try_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_array_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
+        <V as VisitMut>::visit_mut_ts_array_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_as_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
+        <V as VisitMut>::visit_mut_ts_as_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(
-        &mut self,
-        node: &mut TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
+        <V as VisitMut>::visit_mut_ts_call_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(
-        &mut self,
-        node: &mut TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_conditional_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
+        <V as VisitMut>::visit_mut_ts_conditional_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(
-        &mut self,
-        node: &mut TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_const_assertion(&mut **self, node, __ast_path)
+    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
+        <V as VisitMut>::visit_mut_ts_const_assertion(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(
-        &mut self,
-        node: &mut TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
+        <V as VisitMut>::visit_mut_ts_construct_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(
-        &mut self,
-        node: &mut TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_constructor_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
+        <V as VisitMut>::visit_mut_ts_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_entity_name(&mut **self, node, __ast_path)
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
+        <V as VisitMut>::visit_mut_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
+        <V as VisitMut>::visit_mut_ts_enum_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_member(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
+        <V as VisitMut>::visit_mut_ts_enum_member(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(
-        &mut self,
-        node: &mut TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
+        <V as VisitMut>::visit_mut_ts_enum_member_id(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(
-        &mut self,
-        node: &mut Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_members(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
+        <V as VisitMut>::visit_mut_ts_enum_members(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(
-        &mut self,
-        node: &mut TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_export_assignment(&mut **self, node, __ast_path)
+    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
+        <V as VisitMut>::visit_mut_ts_export_assignment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(
-        &mut self,
-        node: &mut TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(&mut **self, node, __ast_path)
+    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
+        <V as VisitMut>::visit_mut_ts_expr_with_type_args(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(
-        &mut self,
-        node: &mut Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(&mut **self, node, __ast_path)
+    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
+        <V as VisitMut>::visit_mut_ts_expr_with_type_argss(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(
-        &mut self,
-        node: &mut TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(&mut **self, node, __ast_path)
+    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
+        <V as VisitMut>::visit_mut_ts_external_module_ref(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(
-        &mut self,
-        node: &mut TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
+        <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_param(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
+        <V as VisitMut>::visit_mut_ts_fn_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_params(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
+        <V as VisitMut>::visit_mut_ts_fn_params(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
+        <V as VisitMut>::visit_mut_ts_fn_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(
-        &mut self,
-        node: &mut TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_getter_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
+        <V as VisitMut>::visit_mut_ts_getter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(
-        &mut self,
-        node: &mut TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
+        <V as VisitMut>::visit_mut_ts_import_equals_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_import_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
+        <V as VisitMut>::visit_mut_ts_import_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(
-        &mut self,
-        node: &mut TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_index_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
+        <V as VisitMut>::visit_mut_ts_index_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(
-        &mut self,
-        node: &mut TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
+        <V as VisitMut>::visit_mut_ts_indexed_access_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_infer_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
+        <V as VisitMut>::visit_mut_ts_infer_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(
-        &mut self,
-        node: &mut TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_instantiation(&mut **self, node, __ast_path)
+    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
+        <V as VisitMut>::visit_mut_ts_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(
-        &mut self,
-        node: &mut TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_interface_body(&mut **self, node, __ast_path)
+    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
+        <V as VisitMut>::visit_mut_ts_interface_body(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(
-        &mut self,
-        node: &mut TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_interface_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
+        <V as VisitMut>::visit_mut_ts_interface_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(
-        &mut self,
-        node: &mut TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_intersection_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
+        <V as VisitMut>::visit_mut_ts_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(
-        &mut self,
-        node: &mut TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_keyword_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
+        <V as VisitMut>::visit_mut_ts_keyword_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(
-        &mut self,
-        node: &mut TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(&mut **self, node, __ast_path)
+    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
+        <V as VisitMut>::visit_mut_ts_keyword_type_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_lit(&mut **self, node, __ast_path)
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
+        <V as VisitMut>::visit_mut_ts_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_lit_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
+        <V as VisitMut>::visit_mut_ts_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_mapped_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
+        <V as VisitMut>::visit_mut_ts_mapped_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(
-        &mut self,
-        node: &mut TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_method_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
+        <V as VisitMut>::visit_mut_ts_method_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(
-        &mut self,
-        node: &mut TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_block(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
+        <V as VisitMut>::visit_mut_ts_module_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
+        <V as VisitMut>::visit_mut_ts_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_name(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
+        <V as VisitMut>::visit_mut_ts_module_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_ref(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
+        <V as VisitMut>::visit_mut_ts_module_ref(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(
-        &mut self,
-        node: &mut TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_body(&mut **self, node, __ast_path)
+    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
+        <V as VisitMut>::visit_mut_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(
-        &mut self,
-        node: &mut TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
+        <V as VisitMut>::visit_mut_ts_namespace_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(
-        &mut self,
-        node: &mut TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
+        <V as VisitMut>::visit_mut_ts_namespace_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(
-        &mut self,
-        node: &mut TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
+        <V as VisitMut>::visit_mut_ts_non_null_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(
-        &mut self,
-        node: &mut TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_optional_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
+        <V as VisitMut>::visit_mut_ts_optional_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_param_prop(&mut **self, node, __ast_path)
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
+        <V as VisitMut>::visit_mut_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(
-        &mut self,
-        node: &mut TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(&mut **self, node, __ast_path)
+    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
+        <V as VisitMut>::visit_mut_ts_param_prop_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(
-        &mut self,
-        node: &mut TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
+        <V as VisitMut>::visit_mut_ts_parenthesized_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(
-        &mut self,
-        node: &mut TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_property_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
+        <V as VisitMut>::visit_mut_ts_property_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(
-        &mut self,
-        node: &mut TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_qualified_name(&mut **self, node, __ast_path)
+    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
+        <V as VisitMut>::visit_mut_ts_qualified_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_rest_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
+        <V as VisitMut>::visit_mut_ts_rest_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(
-        &mut self,
-        node: &mut TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
+        <V as VisitMut>::visit_mut_ts_satisfies_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(
-        &mut self,
-        node: &mut TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_setter_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
+        <V as VisitMut>::visit_mut_ts_setter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_this_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
+        <V as VisitMut>::visit_mut_ts_this_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(
-        &mut self,
-        node: &mut TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(&mut **self, node, __ast_path)
+    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
+        <V as VisitMut>::visit_mut_ts_this_type_or_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
+        <V as VisitMut>::visit_mut_ts_tpl_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(
-        &mut self,
-        node: &mut TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_element(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
+        <V as VisitMut>::visit_mut_ts_tuple_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(
-        &mut self,
-        node: &mut Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
+        <V as VisitMut>::visit_mut_ts_tuple_elements(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
+        <V as VisitMut>::visit_mut_ts_tuple_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
+        <V as VisitMut>::visit_mut_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(
-        &mut self,
-        node: &mut TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
+        <V as VisitMut>::visit_mut_ts_type_alias_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_ann(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
+        <V as VisitMut>::visit_mut_ts_type_ann(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(
-        &mut self,
-        node: &mut TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_assertion(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
+        <V as VisitMut>::visit_mut_ts_type_assertion(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(
-        &mut self,
-        node: &mut TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_element(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
+        <V as VisitMut>::visit_mut_ts_type_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(
-        &mut self,
-        node: &mut Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_elements(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
+        <V as VisitMut>::visit_mut_ts_type_elements(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_lit(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
+        <V as VisitMut>::visit_mut_ts_type_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(
-        &mut self,
-        node: &mut TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_operator(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
+        <V as VisitMut>::visit_mut_ts_type_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(
-        &mut self,
-        node: &mut TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
+        <V as VisitMut>::visit_mut_ts_type_operator_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
+        <V as VisitMut>::visit_mut_ts_type_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(
-        &mut self,
-        node: &mut TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
+        <V as VisitMut>::visit_mut_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(
-        &mut self,
-        node: &mut TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
+        <V as VisitMut>::visit_mut_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(
-        &mut self,
-        node: &mut Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_params(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
+        <V as VisitMut>::visit_mut_ts_type_params(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(
-        &mut self,
-        node: &mut TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_predicate(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
+        <V as VisitMut>::visit_mut_ts_type_predicate(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_query(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
+        <V as VisitMut>::visit_mut_ts_type_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(
-        &mut self,
-        node: &mut TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
+        <V as VisitMut>::visit_mut_ts_type_query_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_ref(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
+        <V as VisitMut>::visit_mut_ts_type_ref(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_types(&mut **self, node, __ast_path)
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
+        <V as VisitMut>::visit_mut_ts_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(
-        &mut self,
-        node: &mut TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
+        <V as VisitMut>::visit_mut_ts_union_or_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_union_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
+        <V as VisitMut>::visit_mut_ts_union_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unary_expr(&mut **self, node, __ast_path)
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
+        <V as VisitMut>::visit_mut_unary_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unary_op(&mut **self, node, __ast_path)
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
+        <V as VisitMut>::visit_mut_unary_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_update_expr(&mut **self, node, __ast_path)
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
+        <V as VisitMut>::visit_mut_update_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_update_op(&mut **self, node, __ast_path)
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
+        <V as VisitMut>::visit_mut_update_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_using_decl(&mut **self, node, __ast_path)
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
+        <V as VisitMut>::visit_mut_using_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_decl(&mut **self, node, __ast_path)
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
+        <V as VisitMut>::visit_mut_var_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_decl_kind(&mut **self, node, __ast_path)
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
+        <V as VisitMut>::visit_mut_var_decl_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(
-        &mut self,
-        node: &mut VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
+        <V as VisitMut>::visit_mut_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_declarator(&mut **self, node, __ast_path)
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
+        <V as VisitMut>::visit_mut_var_declarator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_declarators(
-        &mut self,
-        node: &mut Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_var_declarators(&mut **self, node, __ast_path)
+    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
+        <V as VisitMut>::visit_mut_var_declarators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_while_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
+        <V as VisitMut>::visit_mut_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_with_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
+        <V as VisitMut>::visit_mut_with_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_yield_expr(&mut **self, node, __ast_path)
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
+        <V as VisitMut>::visit_mut_yield_expr(&mut **self, node)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitMutAstPath for Box<V>
+impl<V> VisitMut for Box<V>
 where
-    V: ?Sized + VisitMutAstPath,
+    V: ?Sized + VisitMut,
 {
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_accessibility(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_array_lit(&mut **self, node, __ast_path)
-    }
-
-    #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_array_pat(&mut **self, node, __ast_path)
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
+        <V as VisitMut>::visit_mut_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_arrow_expr(&mut **self, node, __ast_path)
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
+        <V as VisitMut>::visit_mut_array_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_expr(&mut **self, node, __ast_path)
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
+        <V as VisitMut>::visit_mut_array_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_op(&mut **self, node, __ast_path)
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
+        <V as VisitMut>::visit_mut_arrow_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_pat(&mut **self, node, __ast_path)
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
+        <V as VisitMut>::visit_mut_assign_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(
-        &mut self,
-        node: &mut AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_assign_pat_prop(&mut **self, node, __ast_path)
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
+        <V as VisitMut>::visit_mut_assign_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_prop(&mut **self, node, __ast_path)
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
+        <V as VisitMut>::visit_mut_assign_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_target(&mut **self, node, __ast_path)
+    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
+        <V as VisitMut>::visit_mut_assign_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(
-        &mut self,
-        node: &mut AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_assign_target_pat(&mut **self, node, __ast_path)
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
+        <V as VisitMut>::visit_mut_assign_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
+        <V as VisitMut>::visit_mut_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_auto_accessor(&mut **self, node, __ast_path)
+    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
+        <V as VisitMut>::visit_mut_assign_target_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_await_expr(&mut **self, node, __ast_path)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
+        <V as VisitMut>::visit_mut_atom(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_big_int(&mut **self, node, __ast_path)
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
+        <V as VisitMut>::visit_mut_auto_accessor(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_big_int_value(&mut **self, node, __ast_path)
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
+        <V as VisitMut>::visit_mut_await_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bin_expr(&mut **self, node, __ast_path)
+    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
+        <V as VisitMut>::visit_mut_big_int(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_binary_op(&mut **self, node, __ast_path)
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
+        <V as VisitMut>::visit_mut_big_int_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_binding_ident(&mut **self, node, __ast_path)
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
+        <V as VisitMut>::visit_mut_bin_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_block_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
+        <V as VisitMut>::visit_mut_binary_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(
-        &mut self,
-        node: &mut BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(&mut **self, node, __ast_path)
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
+        <V as VisitMut>::visit_mut_binding_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bool(&mut **self, node, __ast_path)
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
+        <V as VisitMut>::visit_mut_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_break_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
+        <V as VisitMut>::visit_mut_block_stmt_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_call_expr(&mut **self, node, __ast_path)
+    fn visit_mut_bool(&mut self, node: &mut Bool) {
+        <V as VisitMut>::visit_mut_bool(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_callee(&mut **self, node, __ast_path)
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
+        <V as VisitMut>::visit_mut_break_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_catch_clause(&mut **self, node, __ast_path)
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
+        <V as VisitMut>::visit_mut_call_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class(&mut **self, node, __ast_path)
+    fn visit_mut_callee(&mut self, node: &mut Callee) {
+        <V as VisitMut>::visit_mut_callee(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_decl(&mut **self, node, __ast_path)
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
+        <V as VisitMut>::visit_mut_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_expr(&mut **self, node, __ast_path)
+    fn visit_mut_class(&mut self, node: &mut Class) {
+        <V as VisitMut>::visit_mut_class(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_member(&mut **self, node, __ast_path)
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
+        <V as VisitMut>::visit_mut_class_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_members(
-        &mut self,
-        node: &mut Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_class_members(&mut **self, node, __ast_path)
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
+        <V as VisitMut>::visit_mut_class_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_method(&mut **self, node, __ast_path)
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
+        <V as VisitMut>::visit_mut_class_member(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_prop(&mut **self, node, __ast_path)
+    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
+        <V as VisitMut>::visit_mut_class_members(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(
-        &mut self,
-        node: &mut ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_computed_prop_name(&mut **self, node, __ast_path)
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
+        <V as VisitMut>::visit_mut_class_method(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_cond_expr(&mut **self, node, __ast_path)
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
+        <V as VisitMut>::visit_mut_class_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_constructor(&mut **self, node, __ast_path)
+    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
+        <V as VisitMut>::visit_mut_computed_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_continue_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
+        <V as VisitMut>::visit_mut_cond_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_debugger_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
+        <V as VisitMut>::visit_mut_constructor(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decl(&mut **self, node, __ast_path)
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
+        <V as VisitMut>::visit_mut_continue_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decorator(&mut **self, node, __ast_path)
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
+        <V as VisitMut>::visit_mut_debugger_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decorators(&mut **self, node, __ast_path)
+    fn visit_mut_decl(&mut self, node: &mut Decl) {
+        <V as VisitMut>::visit_mut_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_default_decl(&mut **self, node, __ast_path)
+    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
+        <V as VisitMut>::visit_mut_decorator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_do_while_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
+        <V as VisitMut>::visit_mut_decorators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_empty_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
+        <V as VisitMut>::visit_mut_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_es_version(&mut **self, node, __ast_path)
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
+        <V as VisitMut>::visit_mut_do_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_all(&mut **self, node, __ast_path)
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
+        <V as VisitMut>::visit_mut_empty_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_decl(&mut **self, node, __ast_path)
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
+        <V as VisitMut>::visit_mut_es_version(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(
-        &mut self,
-        node: &mut ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_default_decl(&mut **self, node, __ast_path)
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
+        <V as VisitMut>::visit_mut_export_all(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(
-        &mut self,
-        node: &mut ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_default_expr(&mut **self, node, __ast_path)
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
+        <V as VisitMut>::visit_mut_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(
-        &mut self,
-        node: &mut ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_default_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
+        <V as VisitMut>::visit_mut_export_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(
-        &mut self,
-        node: &mut ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_named_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
+        <V as VisitMut>::visit_mut_export_default_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(
-        &mut self,
-        node: &mut ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
+        <V as VisitMut>::visit_mut_export_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_specifier(
-        &mut self,
-        node: &mut ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
+        <V as VisitMut>::visit_mut_export_named_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(
-        &mut self,
-        node: &mut Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_export_specifiers(&mut **self, node, __ast_path)
+    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
+        <V as VisitMut>::visit_mut_export_namespace_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr(&mut **self, node, __ast_path)
+    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
+        <V as VisitMut>::visit_mut_export_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
+        <V as VisitMut>::visit_mut_export_specifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_expr_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_expr(&mut self, node: &mut Expr) {
+        <V as VisitMut>::visit_mut_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
+        <V as VisitMut>::visit_mut_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_exprs(&mut **self, node, __ast_path)
+    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
+        <V as VisitMut>::visit_mut_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_fn_decl(&mut **self, node, __ast_path)
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
+        <V as VisitMut>::visit_mut_expr_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_fn_expr(&mut **self, node, __ast_path)
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
+        <V as VisitMut>::visit_mut_exprs(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_head(&mut **self, node, __ast_path)
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
+        <V as VisitMut>::visit_mut_fn_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_in_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
+        <V as VisitMut>::visit_mut_fn_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_of_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
+        <V as VisitMut>::visit_mut_for_head(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
+        <V as VisitMut>::visit_mut_for_in_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
+        <V as VisitMut>::visit_mut_for_of_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_getter_prop(&mut **self, node, __ast_path)
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
+        <V as VisitMut>::visit_mut_for_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
+    fn visit_mut_function(&mut self, node: &mut Function) {
+        <V as VisitMut>::visit_mut_function(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident_name(&mut **self, node, __ast_path)
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
+        <V as VisitMut>::visit_mut_getter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_if_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
+        <V as VisitMut>::visit_mut_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import(&mut **self, node, __ast_path)
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
+        <V as VisitMut>::visit_mut_ident_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_decl(&mut **self, node, __ast_path)
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
+        <V as VisitMut>::visit_mut_if_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(
-        &mut self,
-        node: &mut ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_default_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import(&mut self, node: &mut Import) {
+        <V as VisitMut>::visit_mut_import(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(
-        &mut self,
-        node: &mut ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_named_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
+        <V as VisitMut>::visit_mut_import_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_phase(&mut **self, node, __ast_path)
+    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
+        <V as VisitMut>::visit_mut_import_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_specifier(
-        &mut self,
-        node: &mut ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
+        <V as VisitMut>::visit_mut_import_named_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(
-        &mut self,
-        node: &mut Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_specifiers(&mut **self, node, __ast_path)
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
+        <V as VisitMut>::visit_mut_import_phase(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(
-        &mut self,
-        node: &mut ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(&mut **self, node, __ast_path)
+    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
+        <V as VisitMut>::visit_mut_import_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_with(&mut **self, node, __ast_path)
+    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
+        <V as VisitMut>::visit_mut_import_specifiers(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_with_item(
-        &mut self,
-        node: &mut ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_with_item(&mut **self, node, __ast_path)
+    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
+        <V as VisitMut>::visit_mut_import_star_as_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_import_with_items(
-        &mut self,
-        node: &mut Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_import_with_items(&mut **self, node, __ast_path)
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
+        <V as VisitMut>::visit_mut_import_with(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_invalid(&mut **self, node, __ast_path)
+    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
+        <V as VisitMut>::visit_mut_import_with_item(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr(&mut **self, node, __ast_path)
+    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
+        <V as VisitMut>::visit_mut_import_with_items(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_name(&mut **self, node, __ast_path)
+    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
+        <V as VisitMut>::visit_mut_invalid(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(
-        &mut self,
-        node: &mut JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
+        <V as VisitMut>::visit_mut_jsx_attr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(
-        &mut self,
-        node: &mut Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
+        <V as VisitMut>::visit_mut_jsx_attr_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_value(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
+        <V as VisitMut>::visit_mut_jsx_attr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(
-        &mut self,
-        node: &mut JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_closing_element(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
+        <V as VisitMut>::visit_mut_jsx_attr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(
-        &mut self,
-        node: &mut JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
+        <V as VisitMut>::visit_mut_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
+        <V as VisitMut>::visit_mut_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(
-        &mut self,
-        node: &mut JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_child(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
+        <V as VisitMut>::visit_mut_jsx_closing_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(
-        &mut self,
-        node: &mut Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_childs(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
+        <V as VisitMut>::visit_mut_jsx_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(
-        &mut self,
-        node: &mut JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_name(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
+        <V as VisitMut>::visit_mut_jsx_element_child(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
+        <V as VisitMut>::visit_mut_jsx_element_childs(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_expr(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
+        <V as VisitMut>::visit_mut_jsx_element_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(
-        &mut self,
-        node: &mut JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_expr_container(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
+        <V as VisitMut>::visit_mut_jsx_empty_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_fragment(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
+        <V as VisitMut>::visit_mut_jsx_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(
-        &mut self,
-        node: &mut JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_member_expr(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
+        <V as VisitMut>::visit_mut_jsx_expr_container(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(
-        &mut self,
-        node: &mut JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
+        <V as VisitMut>::visit_mut_jsx_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_object(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
+        <V as VisitMut>::visit_mut_jsx_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(
-        &mut self,
-        node: &mut JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_opening_element(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
+        <V as VisitMut>::visit_mut_jsx_namespaced_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(
-        &mut self,
-        node: &mut JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
+        <V as VisitMut>::visit_mut_jsx_object(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(
-        &mut self,
-        node: &mut JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_jsx_spread_child(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
+        <V as VisitMut>::visit_mut_jsx_opening_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_text(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
+        <V as VisitMut>::visit_mut_jsx_opening_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_key(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
+        <V as VisitMut>::visit_mut_jsx_spread_child(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(
-        &mut self,
-        node: &mut KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(&mut **self, node, __ast_path)
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
+        <V as VisitMut>::visit_mut_jsx_text(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_key_value_prop(&mut **self, node, __ast_path)
+    fn visit_mut_key(&mut self, node: &mut Key) {
+        <V as VisitMut>::visit_mut_key(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_labeled_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
+        <V as VisitMut>::visit_mut_key_value_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_lit(&mut **self, node, __ast_path)
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
+        <V as VisitMut>::visit_mut_key_value_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_member_expr(&mut **self, node, __ast_path)
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
+        <V as VisitMut>::visit_mut_labeled_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_member_prop(&mut **self, node, __ast_path)
+    fn visit_mut_lit(&mut self, node: &mut Lit) {
+        <V as VisitMut>::visit_mut_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_meta_prop_expr(&mut **self, node, __ast_path)
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
+        <V as VisitMut>::visit_mut_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_meta_prop_kind(&mut **self, node, __ast_path)
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
+        <V as VisitMut>::visit_mut_member_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_method_kind(&mut **self, node, __ast_path)
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
+        <V as VisitMut>::visit_mut_meta_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_method_prop(&mut **self, node, __ast_path)
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
+        <V as VisitMut>::visit_mut_meta_prop_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module(&mut **self, node, __ast_path)
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
+        <V as VisitMut>::visit_mut_method_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_decl(&mut **self, node, __ast_path)
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
+        <V as VisitMut>::visit_mut_method_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_export_name(
-        &mut self,
-        node: &mut ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_module_export_name(&mut **self, node, __ast_path)
+    fn visit_mut_module(&mut self, node: &mut Module) {
+        <V as VisitMut>::visit_mut_module(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_item(&mut **self, node, __ast_path)
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
+        <V as VisitMut>::visit_mut_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_items(&mut **self, node, __ast_path)
+    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
+        <V as VisitMut>::visit_mut_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_named_export(&mut **self, node, __ast_path)
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
+        <V as VisitMut>::visit_mut_module_item(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_new_expr(&mut **self, node, __ast_path)
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
+        <V as VisitMut>::visit_mut_module_items(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_null(&mut **self, node, __ast_path)
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
+        <V as VisitMut>::visit_mut_named_export(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
+        <V as VisitMut>::visit_mut_new_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_lit(&mut **self, node, __ast_path)
+    fn visit_mut_null(&mut self, node: &mut Null) {
+        <V as VisitMut>::visit_mut_null(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_pat(&mut **self, node, __ast_path)
+    fn visit_mut_number(&mut self, node: &mut Number) {
+        <V as VisitMut>::visit_mut_number(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(
-        &mut self,
-        node: &mut ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_object_pat_prop(&mut **self, node, __ast_path)
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
+        <V as VisitMut>::visit_mut_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(
-        &mut self,
-        node: &mut Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_object_pat_props(&mut **self, node, __ast_path)
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
+        <V as VisitMut>::visit_mut_object_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(
-        &mut self,
-        node: &mut Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_accessibility(&mut **self, node, __ast_path)
+    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
+        <V as VisitMut>::visit_mut_object_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
+    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
+        <V as VisitMut>::visit_mut_object_pat_props(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_block_stmt(
-        &mut self,
-        node: &mut Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_block_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
+        <V as VisitMut>::visit_mut_opt_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_call(&mut **self, node, __ast_path)
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
+        <V as VisitMut>::visit_mut_opt_atom(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(
-        &mut self,
-        node: &mut Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_catch_clause(&mut **self, node, __ast_path)
+    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
+        <V as VisitMut>::visit_mut_opt_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_chain_base(&mut **self, node, __ast_path)
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
+        <V as VisitMut>::visit_mut_opt_call(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_chain_expr(&mut **self, node, __ast_path)
+    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
+        <V as VisitMut>::visit_mut_opt_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr(&mut **self, node, __ast_path)
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
+        <V as VisitMut>::visit_mut_opt_chain_base(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(
-        &mut self,
-        node: &mut Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
+        <V as VisitMut>::visit_mut_opt_chain_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(
-        &mut self,
-        node: &mut Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
+        <V as VisitMut>::visit_mut_opt_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
+    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
+        <V as VisitMut>::visit_mut_opt_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(
-        &mut self,
-        node: &mut Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(&mut **self, node, __ast_path)
+    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
+        <V as VisitMut>::visit_mut_opt_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(
-        &mut self,
-        node: &mut Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
+        <V as VisitMut>::visit_mut_opt_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(
-        &mut self,
-        node: &mut Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_module_export_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
+        <V as VisitMut>::visit_mut_opt_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(
-        &mut self,
-        node: &mut Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_object_lit(&mut **self, node, __ast_path)
+    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
+        <V as VisitMut>::visit_mut_opt_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_pat(&mut **self, node, __ast_path)
+    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
+        <V as VisitMut>::visit_mut_opt_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_span(
-        &mut self,
-        node: &mut Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_span(&mut **self, node, __ast_path)
+    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
+        <V as VisitMut>::visit_mut_opt_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
+        <V as VisitMut>::visit_mut_opt_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_str(&mut **self, node, __ast_path)
+    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
+        <V as VisitMut>::visit_mut_opt_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(
-        &mut self,
-        node: &mut Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(&mut **self, node, __ast_path)
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
+        <V as VisitMut>::visit_mut_opt_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(
-        &mut self,
-        node: &mut Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(&mut **self, node, __ast_path)
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
+        <V as VisitMut>::visit_mut_opt_str(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(
-        &mut self,
-        node: &mut Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(&mut **self, node, __ast_path)
+    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
+        <V as VisitMut>::visit_mut_opt_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(
-        &mut self,
-        node: &mut Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
+        <V as VisitMut>::visit_mut_opt_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(
-        &mut self,
-        node: &mut Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
+        <V as VisitMut>::visit_mut_opt_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(
-        &mut self,
-        node: &mut Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
+        <V as VisitMut>::visit_mut_opt_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_instantiation(
-        &mut self,
-        node: &mut Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
+        <V as VisitMut>::visit_mut_opt_ts_type_ann(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(
-        &mut self,
-        node: &mut Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
+        <V as VisitMut>::visit_mut_opt_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(
+    fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
-        node: &mut Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
+        node: &mut Option<Box<TsTypeParamInstantiation>>,
     ) {
-        <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
+        <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(
-        &mut self,
-        node: &mut Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_opt_vec_pats(&mut **self, node, __ast_path)
+    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
+        <V as VisitMut>::visit_mut_opt_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_param(&mut **self, node, __ast_path)
+    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
+        <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(
-        &mut self,
-        node: &mut ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(&mut **self, node, __ast_path)
+    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
+        <V as VisitMut>::visit_mut_opt_vec_pats(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(
-        &mut self,
-        node: &mut Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(&mut **self, node, __ast_path)
+    fn visit_mut_param(&mut self, node: &mut Param) {
+        <V as VisitMut>::visit_mut_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_params(&mut **self, node, __ast_path)
+    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
+        <V as VisitMut>::visit_mut_param_or_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_paren_expr(&mut **self, node, __ast_path)
+    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
+        <V as VisitMut>::visit_mut_param_or_ts_param_props(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pat(&mut **self, node, __ast_path)
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
+        <V as VisitMut>::visit_mut_params(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pats(&mut **self, node, __ast_path)
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
+        <V as VisitMut>::visit_mut_paren_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_method(&mut **self, node, __ast_path)
+    fn visit_mut_pat(&mut self, node: &mut Pat) {
+        <V as VisitMut>::visit_mut_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_name(&mut **self, node, __ast_path)
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
+        <V as VisitMut>::visit_mut_pats(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_prop(&mut **self, node, __ast_path)
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
+        <V as VisitMut>::visit_mut_private_method(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_program(&mut **self, node, __ast_path)
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
+        <V as VisitMut>::visit_mut_private_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop(&mut **self, node, __ast_path)
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
+        <V as VisitMut>::visit_mut_private_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop_name(&mut **self, node, __ast_path)
+    fn visit_mut_program(&mut self, node: &mut Program) {
+        <V as VisitMut>::visit_mut_program(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop_or_spread(&mut **self, node, __ast_path)
+    fn visit_mut_prop(&mut self, node: &mut Prop) {
+        <V as VisitMut>::visit_mut_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(
-        &mut self,
-        node: &mut Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_prop_or_spreads(&mut **self, node, __ast_path)
+    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
+        <V as VisitMut>::visit_mut_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_regex(&mut **self, node, __ast_path)
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
+        <V as VisitMut>::visit_mut_prop_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rest_pat(&mut **self, node, __ast_path)
+    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
+        <V as VisitMut>::visit_mut_prop_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_return_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_regex(&mut self, node: &mut Regex) {
+        <V as VisitMut>::visit_mut_regex(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_script(&mut **self, node, __ast_path)
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
+        <V as VisitMut>::visit_mut_rest_pat(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_seq_expr(&mut **self, node, __ast_path)
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
+        <V as VisitMut>::visit_mut_return_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_setter_prop(&mut **self, node, __ast_path)
+    fn visit_mut_script(&mut self, node: &mut Script) {
+        <V as VisitMut>::visit_mut_script(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(
-        &mut self,
-        node: &mut SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_simple_assign_target(&mut **self, node, __ast_path)
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
+        <V as VisitMut>::visit_mut_seq_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
+        <V as VisitMut>::visit_mut_setter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_spread_element(&mut **self, node, __ast_path)
+    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
+        <V as VisitMut>::visit_mut_simple_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_static_block(&mut **self, node, __ast_path)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
+        <V as VisitMut>::visit_mut_span(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
+        <V as VisitMut>::visit_mut_spread_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stmts(&mut **self, node, __ast_path)
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
+        <V as VisitMut>::visit_mut_static_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
+    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
+        <V as VisitMut>::visit_mut_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_super(&mut **self, node, __ast_path)
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
+        <V as VisitMut>::visit_mut_stmts(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_super_prop(&mut **self, node, __ast_path)
+    fn visit_mut_str(&mut self, node: &mut Str) {
+        <V as VisitMut>::visit_mut_str(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(
-        &mut self,
-        node: &mut SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_super_prop_expr(&mut **self, node, __ast_path)
+    fn visit_mut_super(&mut self, node: &mut Super) {
+        <V as VisitMut>::visit_mut_super(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_case(&mut **self, node, __ast_path)
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
+        <V as VisitMut>::visit_mut_super_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_cases(&mut **self, node, __ast_path)
+    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
+        <V as VisitMut>::visit_mut_super_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
+        <V as VisitMut>::visit_mut_switch_case(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_syntax_context(
-        &mut self,
-        node: &mut swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_syntax_context(&mut **self, node, __ast_path)
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
+        <V as VisitMut>::visit_mut_switch_cases(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tagged_tpl(&mut **self, node, __ast_path)
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
+        <V as VisitMut>::visit_mut_switch_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_this_expr(&mut **self, node, __ast_path)
+    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
+        <V as VisitMut>::visit_mut_syntax_context(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_throw_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
+        <V as VisitMut>::visit_mut_tagged_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl(&mut **self, node, __ast_path)
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
+        <V as VisitMut>::visit_mut_this_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl_element(&mut **self, node, __ast_path)
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
+        <V as VisitMut>::visit_mut_throw_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl_elements(&mut **self, node, __ast_path)
+    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
+        <V as VisitMut>::visit_mut_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(
-        &mut self,
-        node: &mut TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_true_plus_minus(&mut **self, node, __ast_path)
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
+        <V as VisitMut>::visit_mut_tpl_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_try_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
+        <V as VisitMut>::visit_mut_tpl_elements(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_array_type(&mut **self, node, __ast_path)
+    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
+        <V as VisitMut>::visit_mut_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_as_expr(&mut **self, node, __ast_path)
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
+        <V as VisitMut>::visit_mut_try_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(
-        &mut self,
-        node: &mut TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
+        <V as VisitMut>::visit_mut_ts_array_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(
-        &mut self,
-        node: &mut TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_conditional_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
+        <V as VisitMut>::visit_mut_ts_as_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(
-        &mut self,
-        node: &mut TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_const_assertion(&mut **self, node, __ast_path)
+    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
+        <V as VisitMut>::visit_mut_ts_call_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(
-        &mut self,
-        node: &mut TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
+        <V as VisitMut>::visit_mut_ts_conditional_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(
-        &mut self,
-        node: &mut TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_constructor_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
+        <V as VisitMut>::visit_mut_ts_const_assertion(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_entity_name(&mut **self, node, __ast_path)
+    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
+        <V as VisitMut>::visit_mut_ts_construct_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
+        <V as VisitMut>::visit_mut_ts_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_member(&mut **self, node, __ast_path)
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
+        <V as VisitMut>::visit_mut_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(
-        &mut self,
-        node: &mut TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
+        <V as VisitMut>::visit_mut_ts_enum_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(
-        &mut self,
-        node: &mut Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_members(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
+        <V as VisitMut>::visit_mut_ts_enum_member(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(
-        &mut self,
-        node: &mut TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_export_assignment(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
+        <V as VisitMut>::visit_mut_ts_enum_member_id(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(
-        &mut self,
-        node: &mut TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(&mut **self, node, __ast_path)
+    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
+        <V as VisitMut>::visit_mut_ts_enum_members(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(
-        &mut self,
-        node: &mut Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(&mut **self, node, __ast_path)
+    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
+        <V as VisitMut>::visit_mut_ts_export_assignment(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(
-        &mut self,
-        node: &mut TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(&mut **self, node, __ast_path)
+    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
+        <V as VisitMut>::visit_mut_ts_expr_with_type_args(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(
-        &mut self,
-        node: &mut TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
+        <V as VisitMut>::visit_mut_ts_expr_with_type_argss(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_param(&mut **self, node, __ast_path)
+    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
+        <V as VisitMut>::visit_mut_ts_external_module_ref(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_params(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
+        <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
+        <V as VisitMut>::visit_mut_ts_fn_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(
-        &mut self,
-        node: &mut TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_getter_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
+        <V as VisitMut>::visit_mut_ts_fn_params(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(
-        &mut self,
-        node: &mut TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
+        <V as VisitMut>::visit_mut_ts_fn_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_import_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
+        <V as VisitMut>::visit_mut_ts_getter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(
-        &mut self,
-        node: &mut TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_index_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
+        <V as VisitMut>::visit_mut_ts_import_equals_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(
-        &mut self,
-        node: &mut TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
+        <V as VisitMut>::visit_mut_ts_import_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_infer_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
+        <V as VisitMut>::visit_mut_ts_index_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(
-        &mut self,
-        node: &mut TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_instantiation(&mut **self, node, __ast_path)
+    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
+        <V as VisitMut>::visit_mut_ts_indexed_access_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(
-        &mut self,
-        node: &mut TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_interface_body(&mut **self, node, __ast_path)
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
+        <V as VisitMut>::visit_mut_ts_infer_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(
-        &mut self,
-        node: &mut TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_interface_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
+        <V as VisitMut>::visit_mut_ts_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(
-        &mut self,
-        node: &mut TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_intersection_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
+        <V as VisitMut>::visit_mut_ts_interface_body(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(
-        &mut self,
-        node: &mut TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_keyword_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
+        <V as VisitMut>::visit_mut_ts_interface_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(
-        &mut self,
-        node: &mut TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(&mut **self, node, __ast_path)
+    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
+        <V as VisitMut>::visit_mut_ts_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_lit(&mut **self, node, __ast_path)
+    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
+        <V as VisitMut>::visit_mut_ts_keyword_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_lit_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
+        <V as VisitMut>::visit_mut_ts_keyword_type_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_mapped_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
+        <V as VisitMut>::visit_mut_ts_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(
-        &mut self,
-        node: &mut TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_method_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
+        <V as VisitMut>::visit_mut_ts_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(
-        &mut self,
-        node: &mut TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_block(&mut **self, node, __ast_path)
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
+        <V as VisitMut>::visit_mut_ts_mapped_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
+        <V as VisitMut>::visit_mut_ts_method_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_name(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
+        <V as VisitMut>::visit_mut_ts_module_block(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_ref(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
+        <V as VisitMut>::visit_mut_ts_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(
-        &mut self,
-        node: &mut TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_body(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
+        <V as VisitMut>::visit_mut_ts_module_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(
-        &mut self,
-        node: &mut TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
+        <V as VisitMut>::visit_mut_ts_module_ref(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(
-        &mut self,
-        node: &mut TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
+        <V as VisitMut>::visit_mut_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(
-        &mut self,
-        node: &mut TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
+        <V as VisitMut>::visit_mut_ts_namespace_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(
-        &mut self,
-        node: &mut TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_optional_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
+        <V as VisitMut>::visit_mut_ts_namespace_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_param_prop(&mut **self, node, __ast_path)
+    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
+        <V as VisitMut>::visit_mut_ts_non_null_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(
-        &mut self,
-        node: &mut TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(&mut **self, node, __ast_path)
+    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
+        <V as VisitMut>::visit_mut_ts_optional_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(
-        &mut self,
-        node: &mut TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
+        <V as VisitMut>::visit_mut_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(
-        &mut self,
-        node: &mut TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_property_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
+        <V as VisitMut>::visit_mut_ts_param_prop_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(
-        &mut self,
-        node: &mut TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_qualified_name(&mut **self, node, __ast_path)
+    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
+        <V as VisitMut>::visit_mut_ts_parenthesized_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_rest_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
+        <V as VisitMut>::visit_mut_ts_property_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(
-        &mut self,
-        node: &mut TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
+        <V as VisitMut>::visit_mut_ts_qualified_name(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(
-        &mut self,
-        node: &mut TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_setter_signature(&mut **self, node, __ast_path)
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
+        <V as VisitMut>::visit_mut_ts_rest_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_this_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
+        <V as VisitMut>::visit_mut_ts_satisfies_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(
-        &mut self,
-        node: &mut TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(&mut **self, node, __ast_path)
+    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
+        <V as VisitMut>::visit_mut_ts_setter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
+        <V as VisitMut>::visit_mut_ts_this_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(
-        &mut self,
-        node: &mut TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_element(&mut **self, node, __ast_path)
+    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
+        <V as VisitMut>::visit_mut_ts_this_type_or_ident(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(
-        &mut self,
-        node: &mut Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
+        <V as VisitMut>::visit_mut_ts_tpl_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
+        <V as VisitMut>::visit_mut_ts_tuple_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
+        <V as VisitMut>::visit_mut_ts_tuple_elements(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(
-        &mut self,
-        node: &mut TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
+        <V as VisitMut>::visit_mut_ts_tuple_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_ann(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
+        <V as VisitMut>::visit_mut_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(
-        &mut self,
-        node: &mut TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_assertion(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
+        <V as VisitMut>::visit_mut_ts_type_alias_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(
-        &mut self,
-        node: &mut TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_element(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
+        <V as VisitMut>::visit_mut_ts_type_ann(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(
-        &mut self,
-        node: &mut Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_elements(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
+        <V as VisitMut>::visit_mut_ts_type_assertion(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_lit(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
+        <V as VisitMut>::visit_mut_ts_type_element(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(
-        &mut self,
-        node: &mut TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_operator(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
+        <V as VisitMut>::visit_mut_ts_type_elements(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(
-        &mut self,
-        node: &mut TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
+        <V as VisitMut>::visit_mut_ts_type_lit(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
+        <V as VisitMut>::visit_mut_ts_type_operator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(
-        &mut self,
-        node: &mut TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
+        <V as VisitMut>::visit_mut_ts_type_operator_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(
-        &mut self,
-        node: &mut TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
+        <V as VisitMut>::visit_mut_ts_type_param(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(
-        &mut self,
-        node: &mut Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_params(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
+        <V as VisitMut>::visit_mut_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(
-        &mut self,
-        node: &mut TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_predicate(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
+        <V as VisitMut>::visit_mut_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_query(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
+        <V as VisitMut>::visit_mut_ts_type_params(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(
-        &mut self,
-        node: &mut TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
+        <V as VisitMut>::visit_mut_ts_type_predicate(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_ref(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
+        <V as VisitMut>::visit_mut_ts_type_query(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_types(&mut **self, node, __ast_path)
+    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
+        <V as VisitMut>::visit_mut_ts_type_query_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(
-        &mut self,
-        node: &mut TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(
-            &mut **self,
-            node,
-            __ast_path,
-        )
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
+        <V as VisitMut>::visit_mut_ts_type_ref(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_union_type(&mut **self, node, __ast_path)
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
+        <V as VisitMut>::visit_mut_ts_types(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unary_expr(&mut **self, node, __ast_path)
+    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
+        <V as VisitMut>::visit_mut_ts_union_or_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unary_op(&mut **self, node, __ast_path)
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
+        <V as VisitMut>::visit_mut_ts_union_type(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_update_expr(&mut **self, node, __ast_path)
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
+        <V as VisitMut>::visit_mut_unary_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_update_op(&mut **self, node, __ast_path)
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
+        <V as VisitMut>::visit_mut_unary_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_using_decl(&mut **self, node, __ast_path)
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
+        <V as VisitMut>::visit_mut_update_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_decl(&mut **self, node, __ast_path)
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
+        <V as VisitMut>::visit_mut_update_op(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_decl_kind(&mut **self, node, __ast_path)
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
+        <V as VisitMut>::visit_mut_using_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(
-        &mut self,
-        node: &mut VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
+        <V as VisitMut>::visit_mut_var_decl(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_declarator(&mut **self, node, __ast_path)
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
+        <V as VisitMut>::visit_mut_var_decl_kind(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_var_declarators(
-        &mut self,
-        node: &mut Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) {
-        <V as VisitMutAstPath>::visit_mut_var_declarators(&mut **self, node, __ast_path)
+    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
+        <V as VisitMut>::visit_mut_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_while_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
+        <V as VisitMut>::visit_mut_var_declarator(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_with_stmt(&mut **self, node, __ast_path)
+    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
+        <V as VisitMut>::visit_mut_var_declarators(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_yield_expr(&mut **self, node, __ast_path)
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<A, B> VisitMutAstPath for ::swc_visit::Either<A, B>
-where
-    A: VisitMutAstPath,
-    B: VisitMutAstPath,
-{
-    #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_accessibility(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_accessibility(visitor, node, __ast_path)
-            }
-        }
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
+        <V as VisitMut>::visit_mut_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
+        <V as VisitMut>::visit_mut_with_stmt(&mut **self, node)
+    }
+
+    #[inline]
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
+        <V as VisitMut>::visit_mut_yield_expr(&mut **self, node)
+    }
+}
+impl<A, B> VisitMut for ::swc_visit::Either<A, B>
+where
+    A: VisitMut,
+    B: VisitMut,
+{
+    #[inline]
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_array_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_array_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_accessibility(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_accessibility(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_array_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_array_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_array_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_array_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_arrow_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_arrow_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_array_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_array_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_assign_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_assign_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_arrow_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_arrow_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_assign_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_assign_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_assign_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_assign_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_op(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_op(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(
-        &mut self,
-        node: &mut AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_assign_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_assign_pat_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_assign_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_assign_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_pat_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_pat_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_assign_target(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_assign_target(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(
-        &mut self,
-        node: &mut AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_assign_target_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_assign_target_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_assign_target(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_assign_target(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
+                VisitMut::visit_mut_assign_target_pat(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
+                VisitMut::visit_mut_assign_target_pat(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_auto_accessor(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_auto_accessor(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_atom(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_await_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_await_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_auto_accessor(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_auto_accessor(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_big_int(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_big_int(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_await_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_await_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_big_int_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_big_int_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_big_int(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_big_int(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_bin_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_bin_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_big_int_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_big_int_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_binary_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_binary_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_bin_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_bin_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_binding_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_binding_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_binary_op(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_binary_op(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_block_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_block_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_binding_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_binding_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(
-        &mut self,
-        node: &mut BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_block_stmt_or_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_block_stmt_or_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_block_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_block_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
+    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_bool(visitor, node, __ast_path)
+                VisitMut::visit_mut_block_stmt_or_expr(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_bool(visitor, node, __ast_path)
+                VisitMut::visit_mut_block_stmt_or_expr(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_bool(&mut self, node: &mut Bool) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_break_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_break_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_bool(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_bool(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_call_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_call_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_break_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_break_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_callee(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_callee(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_call_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_call_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
+    fn visit_mut_callee(&mut self, node: &mut Callee) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_catch_clause(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_catch_clause(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_callee(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_callee(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_catch_clause(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_catch_clause(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class(&mut self, node: &mut Class) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class_member(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class_member(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_class_members(
-        &mut self,
-        node: &mut Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class_members(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class_members(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_member(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_member(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class_method(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class_method(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_members(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_members(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_class_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_class_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_method(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_method(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(
-        &mut self,
-        node: &mut ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_computed_prop_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_computed_prop_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_class_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_class_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_cond_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_computed_prop_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_cond_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_computed_prop_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_constructor(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_constructor(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_cond_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_cond_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_continue_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_continue_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_constructor(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_constructor(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_debugger_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_debugger_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_continue_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_continue_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_debugger_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_debugger_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_decl(&mut self, node: &mut Decl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_decorator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_decorator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_decorators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_decorators(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_decorator(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_decorator(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_default_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_default_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_decorators(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_decorators(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_do_while_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_do_while_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_default_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_default_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_empty_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_empty_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_do_while_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_do_while_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_es_version(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_es_version(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_empty_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_empty_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_all(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_all(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_es_version(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_es_version(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_export_all(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_export_all(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(
-        &mut self,
-        node: &mut ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_default_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_default_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_export_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_export_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(
-        &mut self,
-        node: &mut ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_default_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_default_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_default_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_default_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(
-        &mut self,
-        node: &mut ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_default_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_default_expr(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_default_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_default_expr(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(
-        &mut self,
-        node: &mut ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_named_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_default_specifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_named_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_default_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(
-        &mut self,
-        node: &mut ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_namespace_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_named_specifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_namespace_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_named_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifier(
-        &mut self,
-        node: &mut ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_namespace_specifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_namespace_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(
-        &mut self,
-        node: &mut Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_export_specifiers(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_export_specifier(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_export_specifiers(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_specifiers(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_export_specifiers(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
+    fn visit_mut_expr(&mut self, node: &mut Expr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_expr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_expr_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_expr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_expr_or_spreads(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr_or_spread(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr_or_spread(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_expr_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_expr_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr_or_spreads(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr_or_spreads(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_exprs(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_exprs(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_expr_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_expr_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_fn_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_fn_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_exprs(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_exprs(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_fn_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_fn_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_fn_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_fn_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_for_head(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_for_head(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_fn_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_fn_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_for_in_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_for_in_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_head(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_head(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_for_of_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_for_of_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_in_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_in_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_for_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_for_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_of_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_of_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_for_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_for_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_function(&mut self, node: &mut Function) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_getter_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_getter_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_function(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_function(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_getter_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_getter_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ident_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ident_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_if_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_if_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ident_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ident_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_if_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_if_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import(&mut self, node: &mut Import) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(
-        &mut self,
-        node: &mut ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_default_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_default_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(
-        &mut self,
-        node: &mut ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_named_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_default_specifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_named_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_default_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_phase(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_named_specifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_phase(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_named_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifier(
-        &mut self,
-        node: &mut ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_phase(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_phase(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(
-        &mut self,
-        node: &mut Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_specifiers(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_specifier(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_specifiers(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(
-        &mut self,
-        node: &mut ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_star_as_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_specifiers(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_star_as_specifier(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_specifiers(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_with(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_star_as_specifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_with(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_star_as_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_item(
-        &mut self,
-        node: &mut ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_with_item(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_with_item(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_with(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_import_with(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_items(
-        &mut self,
-        node: &mut Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_import_with_items(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_import_with_item(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_import_with_items(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_with_item(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_invalid(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_with_items(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_invalid(visitor, node, __ast_path)
+                VisitMut::visit_mut_import_with_items(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_invalid(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_invalid(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_attr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_attr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(
-        &mut self,
-        node: &mut JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_attr_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_attr_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(
-        &mut self,
-        node: &mut Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_or_spreads(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_attr_or_spread(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_or_spreads(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_attr_or_spread(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_attr_or_spreads(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_attr_value(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_attr_or_spreads(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(
-        &mut self,
-        node: &mut JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_closing_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_closing_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_attr_value(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_attr_value(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(
-        &mut self,
-        node: &mut JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_closing_fragment(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_closing_element(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_closing_fragment(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_closing_element(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_closing_fragment(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_closing_fragment(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(
-        &mut self,
-        node: &mut JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element_child(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element_child(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_element(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_element(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(
-        &mut self,
-        node: &mut Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element_childs(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_element_child(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element_childs(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_element_child(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(
-        &mut self,
-        node: &mut JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_element_childs(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_element_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_element_childs(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_empty_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_element_name(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_empty_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_element_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_empty_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_empty_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(
-        &mut self,
-        node: &mut JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_expr_container(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_expr_container(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_fragment(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_expr_container(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_fragment(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_expr_container(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(
-        &mut self,
-        node: &mut JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_member_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_member_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_fragment(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_fragment(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(
-        &mut self,
-        node: &mut JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_namespaced_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_namespaced_name(visitor, node, __ast_path)
-            }
+    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
+        match self {
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_member_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_member_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_object(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_namespaced_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_object(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_namespaced_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(
-        &mut self,
-        node: &mut JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_opening_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_opening_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_object(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_object(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(
-        &mut self,
-        node: &mut JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_opening_fragment(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_opening_element(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_opening_fragment(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_opening_element(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(
-        &mut self,
-        node: &mut JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_spread_child(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_opening_fragment(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_spread_child(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_opening_fragment(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_text(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_spread_child(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_jsx_text(visitor, node, __ast_path)
+                VisitMut::visit_mut_jsx_spread_child(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_key(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_key(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_jsx_text(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_jsx_text(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(
-        &mut self,
-        node: &mut KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_key(&mut self, node: &mut Key) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_key_value_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_key_value_pat_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_key(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_key(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_key_value_prop(visitor, node, __ast_path)
+                VisitMut::visit_mut_key_value_pat_prop(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_key_value_prop(visitor, node, __ast_path)
+                VisitMut::visit_mut_key_value_pat_prop(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_labeled_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_labeled_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_key_value_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_key_value_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_labeled_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_labeled_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_lit(&mut self, node: &mut Lit) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_member_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_member_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_member_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_member_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_member_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_member_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_meta_prop_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_meta_prop_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_member_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_member_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_meta_prop_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_meta_prop_kind(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_meta_prop_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_meta_prop_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_method_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_method_kind(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_meta_prop_kind(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_meta_prop_kind(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_method_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_method_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_method_kind(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_method_kind(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_module(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_module(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_method_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_method_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module(&mut self, node: &mut Module) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_module_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_module_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_module_export_name(
-        &mut self,
-        node: &mut ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_module_export_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_module_export_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_module_item(visitor, node, __ast_path)
+                VisitMut::visit_mut_module_export_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_module_item(visitor, node, __ast_path)
+                VisitMut::visit_mut_module_export_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_module_items(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_module_items(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module_item(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module_item(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_named_export(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_named_export(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_module_items(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_module_items(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_new_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_new_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_named_export(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_named_export(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_null(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_null(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_new_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_new_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+    fn visit_mut_null(&mut self, node: &mut Null) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_null(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_null(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_number(&mut self, node: &mut Number) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_object_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_object_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_number(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_number(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_object_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_object_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_object_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(
-        &mut self,
-        node: &mut ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_object_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_object_pat_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_object_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(
-        &mut self,
-        node: &mut Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_object_pat_props(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_object_pat_props(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_pat_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_object_pat_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(
-        &mut self,
-        node: &mut Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_accessibility(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_object_pat_props(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_accessibility(visitor, node, __ast_path)
+                VisitMut::visit_mut_object_pat_props(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_accessibility(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_accessibility(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_block_stmt(
-        &mut self,
-        node: &mut Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_block_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_block_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_atom(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_call(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_call(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_block_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_block_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(
-        &mut self,
-        node: &mut Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_catch_clause(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_catch_clause(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_call(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_call(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_chain_base(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_catch_clause(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_chain_base(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_catch_clause(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_chain_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_chain_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_chain_base(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_chain_base(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_chain_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_chain_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(
-        &mut self,
-        node: &mut Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_expr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_expr_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(
-        &mut self,
-        node: &mut Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_expr_or_spreads(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_expr_or_spread(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_expr_or_spreads(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_expr_or_spread(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_expr_or_spreads(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_expr_or_spreads(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(
-        &mut self,
-        node: &mut Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_jsx_attr_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_jsx_attr_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(
-        &mut self,
-        node: &mut Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_jsx_closing_element(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_jsx_attr_value(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_jsx_closing_element(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_jsx_attr_value(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(
-        &mut self,
-        node: &mut Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_module_export_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_jsx_closing_element(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_module_export_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_jsx_closing_element(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(
-        &mut self,
-        node: &mut Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_object_lit(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_module_export_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_object_lit(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_module_export_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_object_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_object_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_span(
-        &mut self,
-        node: &mut Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_span(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_span(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_span(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_span(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_str(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_str(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(
-        &mut self,
-        node: &mut Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_true_plus_minus(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_true_plus_minus(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_str(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_str(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(
-        &mut self,
-        node: &mut Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_entity_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_true_plus_minus(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_entity_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_true_plus_minus(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(
-        &mut self,
-        node: &mut Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_namespace_body(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_ts_entity_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_namespace_body(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_ts_entity_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(
-        &mut self,
-        node: &mut Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_ts_namespace_body(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_ts_namespace_body(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(
-        &mut self,
-        node: &mut Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type_ann(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type_ann(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ts_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ts_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(
-        &mut self,
-        node: &mut Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type_param_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type_param_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_ts_type_ann(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_ts_type_ann(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_instantiation(
-        &mut self,
-        node: &mut Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type_param_instantiation(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_ts_type_param_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_ts_type_param_instantiation(
-                    visitor, node, __ast_path,
-                )
+                VisitMut::visit_mut_opt_ts_type_param_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(
+    fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
-        node: &mut Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
+        node: &mut Option<Box<TsTypeParamInstantiation>>,
     ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_var_decl_or_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_ts_type_param_instantiation(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_var_decl_or_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_ts_type_param_instantiation(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_vec_expr_or_spreads(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_var_decl_or_expr(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_vec_expr_or_spreads(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_var_decl_or_expr(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(
-        &mut self,
-        node: &mut Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_opt_vec_pats(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_vec_expr_or_spreads(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_opt_vec_pats(visitor, node, __ast_path)
+                VisitMut::visit_mut_opt_vec_expr_or_spreads(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_param(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_opt_vec_pats(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_opt_vec_pats(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(
-        &mut self,
-        node: &mut ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_param(&mut self, node: &mut Param) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_param_or_ts_param_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_param_or_ts_param_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_param(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_param(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(
-        &mut self,
-        node: &mut Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_param_or_ts_param_props(visitor, node, __ast_path)
+                VisitMut::visit_mut_param_or_ts_param_prop(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_param_or_ts_param_props(visitor, node, __ast_path)
+                VisitMut::visit_mut_param_or_ts_param_prop(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_params(visitor, node, __ast_path)
+                VisitMut::visit_mut_param_or_ts_param_props(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_params(visitor, node, __ast_path)
+                VisitMut::visit_mut_param_or_ts_param_props(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_paren_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_paren_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_params(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_params(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_paren_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_paren_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_pat(&mut self, node: &mut Pat) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_pats(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_pats(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_private_method(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_private_method(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_pats(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_pats(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_private_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_private_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_private_method(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_private_method(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_private_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_private_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_private_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_private_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_program(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_program(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_private_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_private_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
+    fn visit_mut_program(&mut self, node: &mut Program) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_program(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_program(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_prop(&mut self, node: &mut Prop) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_prop_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_prop_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
+    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_prop_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_prop_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(
-        &mut self,
-        node: &mut Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_prop_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_prop_or_spreads(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop_or_spread(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop_or_spread(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
+    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_regex(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_regex(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_prop_or_spreads(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_prop_or_spreads(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_regex(&mut self, node: &mut Regex) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_rest_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_rest_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_regex(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_regex(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_return_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_return_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_rest_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_rest_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_script(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_script(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_return_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_return_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_script(&mut self, node: &mut Script) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_seq_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_seq_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_script(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_script(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_setter_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_setter_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_seq_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_seq_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(
-        &mut self,
-        node: &mut SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_simple_assign_target(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_simple_assign_target(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_setter_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_setter_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
+                VisitMut::visit_mut_simple_assign_target(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
+                VisitMut::visit_mut_simple_assign_target(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_spread_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_spread_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_span(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_span(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_static_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_static_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_spread_element(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_spread_element(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_static_block(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_static_block(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_stmts(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_stmts(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_stmts(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_stmts(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
+    fn visit_mut_str(&mut self, node: &mut Str) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_super(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_super(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_str(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_str(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_super(&mut self, node: &mut Super) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_super_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_super_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_super(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_super(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(
-        &mut self,
-        node: &mut SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_super_prop_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_super_prop_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_super_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_super_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
+    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_switch_case(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_switch_case(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_super_prop_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_super_prop_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_switch_cases(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_switch_cases(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_switch_case(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_switch_case(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_switch_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_switch_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_switch_cases(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_switch_cases(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_syntax_context(
-        &mut self,
-        node: &mut swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_syntax_context(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_syntax_context(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_switch_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_switch_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_tagged_tpl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_tagged_tpl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_syntax_context(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_syntax_context(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_this_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_this_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tagged_tpl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tagged_tpl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_throw_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_throw_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_this_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_this_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_tpl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_tpl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_throw_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_throw_stmt(visitor, node),
+        }
+    }
+
+    #[inline]
+    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
+        match self {
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tpl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tpl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_tpl_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_tpl_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tpl_element(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tpl_element(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_tpl_elements(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_tpl_elements(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_tpl_elements(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_tpl_elements(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(
-        &mut self,
-        node: &mut TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_true_plus_minus(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_true_plus_minus(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_true_plus_minus(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_true_plus_minus(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_try_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_try_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_try_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_try_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_array_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_array_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_array_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_array_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_as_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_as_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_as_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_as_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(
-        &mut self,
-        node: &mut TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_call_signature_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_call_signature_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_call_signature_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_call_signature_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(
-        &mut self,
-        node: &mut TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_conditional_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_conditional_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_conditional_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_conditional_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(
-        &mut self,
-        node: &mut TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_const_assertion(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_const_assertion(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_const_assertion(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_const_assertion(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(
-        &mut self,
-        node: &mut TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_construct_signature_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_construct_signature_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_construct_signature_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_construct_signature_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(
-        &mut self,
-        node: &mut TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_constructor_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_constructor_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_constructor_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_constructor_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_entity_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_entity_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_entity_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_entity_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_enum_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_enum_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_member(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_member(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_enum_member(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_enum_member(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(
-        &mut self,
-        node: &mut TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_member_id(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_enum_member_id(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_member_id(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_enum_member_id(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(
-        &mut self,
-        node: &mut Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_members(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_enum_members(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_enum_members(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_enum_members(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(
-        &mut self,
-        node: &mut TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_export_assignment(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_export_assignment(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_export_assignment(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_export_assignment(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(
-        &mut self,
-        node: &mut TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_expr_with_type_args(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_expr_with_type_args(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_expr_with_type_args(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_expr_with_type_args(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(
-        &mut self,
-        node: &mut Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_expr_with_type_argss(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_expr_with_type_argss(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_expr_with_type_argss(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_expr_with_type_argss(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(
-        &mut self,
-        node: &mut TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_external_module_ref(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_external_module_ref(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_external_module_ref(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_external_module_ref(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(
-        &mut self,
-        node: &mut TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_or_constructor_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_fn_or_constructor_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_or_constructor_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_fn_or_constructor_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_param(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_fn_param(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_fn_param(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_params(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_params(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_fn_params(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_fn_params(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_fn_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_fn_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_fn_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(
-        &mut self,
-        node: &mut TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_getter_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_getter_signature(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_getter_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_getter_signature(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(
-        &mut self,
-        node: &mut TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_import_equals_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_import_equals_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_import_equals_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_import_equals_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_import_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_import_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_import_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_import_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(
-        &mut self,
-        node: &mut TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_index_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_index_signature(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_index_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_index_signature(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(
-        &mut self,
-        node: &mut TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_indexed_access_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_indexed_access_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_indexed_access_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_indexed_access_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_infer_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_infer_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_infer_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_infer_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(
-        &mut self,
-        node: &mut TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_instantiation(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_instantiation(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_instantiation(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_instantiation(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(
-        &mut self,
-        node: &mut TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_interface_body(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_interface_body(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_interface_body(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_interface_body(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(
-        &mut self,
-        node: &mut TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_interface_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_interface_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_interface_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_interface_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(
-        &mut self,
-        node: &mut TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_intersection_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_intersection_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_intersection_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_intersection_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(
-        &mut self,
-        node: &mut TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_keyword_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_keyword_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_keyword_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_keyword_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(
-        &mut self,
-        node: &mut TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_keyword_type_kind(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_keyword_type_kind(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_keyword_type_kind(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_keyword_type_kind(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_lit_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_lit_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_lit_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_lit_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_mapped_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_mapped_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_mapped_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_mapped_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(
-        &mut self,
-        node: &mut TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_method_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_method_signature(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_method_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_method_signature(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(
-        &mut self,
-        node: &mut TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_block(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_block(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_name(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_name(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_module_ref(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_module_ref(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_module_ref(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(
-        &mut self,
-        node: &mut TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_namespace_body(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_namespace_body(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_namespace_body(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_namespace_body(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(
-        &mut self,
-        node: &mut TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_namespace_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_namespace_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_namespace_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_namespace_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(
-        &mut self,
-        node: &mut TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_namespace_export_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_namespace_export_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_namespace_export_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_namespace_export_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(
-        &mut self,
-        node: &mut TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_non_null_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_non_null_expr(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_non_null_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_non_null_expr(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(
-        &mut self,
-        node: &mut TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_optional_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_optional_type(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_optional_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_optional_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_param_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_param_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_param_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_param_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(
-        &mut self,
-        node: &mut TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_param_prop_param(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_param_prop_param(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_param_prop_param(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_param_prop_param(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(
-        &mut self,
-        node: &mut TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_parenthesized_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_parenthesized_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_parenthesized_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_parenthesized_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(
-        &mut self,
-        node: &mut TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_property_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_property_signature(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_property_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_property_signature(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(
-        &mut self,
-        node: &mut TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_qualified_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_qualified_name(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_qualified_name(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_qualified_name(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_rest_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_rest_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_rest_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_rest_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(
-        &mut self,
-        node: &mut TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_satisfies_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_satisfies_expr(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_satisfies_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_satisfies_expr(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(
-        &mut self,
-        node: &mut TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_setter_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_setter_signature(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_setter_signature(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_setter_signature(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_this_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_this_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_this_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_this_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(
-        &mut self,
-        node: &mut TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_this_type_or_ident(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_this_type_or_ident(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_this_type_or_ident(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_this_type_or_ident(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tpl_lit_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tpl_lit_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_tpl_lit_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_tpl_lit_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(
-        &mut self,
-        node: &mut TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tuple_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_tuple_element(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tuple_element(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_tuple_element(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(
-        &mut self,
-        node: &mut Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tuple_elements(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_tuple_elements(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tuple_elements(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_tuple_elements(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tuple_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_tuple_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_tuple_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_tuple_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(
-        &mut self,
-        node: &mut TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_alias_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_alias_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_alias_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_alias_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_ann(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_ann(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_ann(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_ann(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(
-        &mut self,
-        node: &mut TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_assertion(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_assertion(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_assertion(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_assertion(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(
-        &mut self,
-        node: &mut TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_element(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_element(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(
-        &mut self,
-        node: &mut Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_elements(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_elements(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_elements(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_elements(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(
-        &mut self,
-        node: &mut TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_operator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_operator(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_operator(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_operator(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(
-        &mut self,
-        node: &mut TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_operator_op(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_operator_op(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_operator_op(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_operator_op(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_param(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_param(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_param(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(
-        &mut self,
-        node: &mut TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_param_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_param_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_param_decl(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_param_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(
-        &mut self,
-        node: &mut TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_param_instantiation(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_param_instantiation(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_param_instantiation(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_param_instantiation(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(
-        &mut self,
-        node: &mut Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_params(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_params(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_params(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_params(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(
-        &mut self,
-        node: &mut TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_predicate(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_predicate(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_predicate(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_predicate(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_query(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_query(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_query(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(
-        &mut self,
-        node: &mut TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_query_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_query_expr(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_query_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_type_query_expr(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_type_ref(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_type_ref(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_type_ref(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_types(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_types(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_types(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(
-        &mut self,
-        node: &mut TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_union_or_intersection_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_union_or_intersection_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_union_or_intersection_type(visitor, node, __ast_path)
+                VisitMut::visit_mut_ts_union_or_intersection_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_ts_union_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_ts_union_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_ts_union_type(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_ts_union_type(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_unary_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_unary_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_unary_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_unary_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_unary_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_unary_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_unary_op(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_unary_op(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_update_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_update_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_update_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_update_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_update_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_update_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_update_op(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_update_op(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_using_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_using_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_using_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_using_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_var_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_var_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_var_decl_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_var_decl_kind(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_decl_kind(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_decl_kind(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(
-        &mut self,
-        node: &mut VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_var_decl_or_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_decl_or_expr(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_var_decl_or_expr(visitor, node, __ast_path)
+                VisitMut::visit_mut_var_decl_or_expr(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_var_declarator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_var_declarator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_declarator(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_declarator(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarators(
-        &mut self,
-        node: &mut Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_var_declarators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_var_declarators(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_var_declarators(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_var_declarators(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_while_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_while_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_while_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_while_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_with_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_with_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_with_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_with_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitMutAstPath::visit_mut_yield_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitMutAstPath::visit_mut_yield_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => VisitMut::visit_mut_yield_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => VisitMut::visit_mut_yield_expr(visitor, node),
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitMutAstPath for ::swc_visit::Optional<V>
+impl<V> VisitMut for ::swc_visit::Optional<V>
 where
-    V: VisitMutAstPath,
+    V: VisitMut,
 {
     #[inline]
-    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_accessibility(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_accessibility(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_array_lit(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_array_lit(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_array_pat(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_array_pat(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_arrow_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_arrow_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_assign_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_assign_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_assign_op(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_assign_op(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_assign_pat(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_assign_pat(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_pat_prop(
-        &mut self,
-        node: &mut AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_assign_pat_prop(&mut self, node: &mut AssignPatProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_assign_pat_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_assign_pat_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_assign_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_assign_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_assign_target(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_assign_target(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_assign_target_pat(
-        &mut self,
-        node: &mut AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_assign_target_pat(&mut self, node: &mut AssignTargetPat) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_assign_target_pat(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_assign_target_pat(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_atom(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_atom(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_auto_accessor(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_auto_accessor(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_await_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_await_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_big_int(&mut self, node: &mut BigInt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_big_int(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_big_int(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_big_int_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_big_int_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_bin_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_bin_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_binary_op(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_binary_op(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_binding_ident(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_binding_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_block_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_block_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_block_stmt_or_expr(
-        &mut self,
-        node: &mut BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_block_stmt_or_expr(&mut self, node: &mut BlockStmtOrExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_block_stmt_or_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
+    fn visit_mut_bool(&mut self, node: &mut Bool) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_bool(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_bool(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_break_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_break_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_call_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_call_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
+    fn visit_mut_callee(&mut self, node: &mut Callee) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_callee(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_callee(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_catch_clause(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_catch_clause(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class(&mut self, node: &mut Class) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class_member(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class_member(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_members(
-        &mut self,
-        node: &mut Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_class_members(&mut self, node: &mut Vec<ClassMember>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class_members(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class_members(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class_method(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class_method(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_class_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_class_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_computed_prop_name(
-        &mut self,
-        node: &mut ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_computed_prop_name(&mut self, node: &mut ComputedPropName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_computed_prop_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_computed_prop_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_cond_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_cond_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
+    fn visit_mut_constructor(&mut self, node: &mut Constructor) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_constructor(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_constructor(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_continue_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_continue_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_debugger_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_debugger_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_decl(&mut self, node: &mut Decl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_decorator(&mut self, node: &mut Decorator) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_decorator(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_decorator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_decorators(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_decorators(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_default_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_default_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_do_while_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_do_while_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_empty_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_empty_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_es_version(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_es_version(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_all(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_export_all(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_export_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_decl(
-        &mut self,
-        node: &mut ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_default_decl(&mut self, node: &mut ExportDefaultDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_default_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_export_default_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_expr(
-        &mut self,
-        node: &mut ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_default_expr(&mut self, node: &mut ExportDefaultExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_default_expr(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_export_default_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_default_specifier(
-        &mut self,
-        node: &mut ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_default_specifier(&mut self, node: &mut ExportDefaultSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_default_specifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_export_default_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_named_specifier(
-        &mut self,
-        node: &mut ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_named_specifier(&mut self, node: &mut ExportNamedSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_named_specifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_export_named_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_namespace_specifier(
-        &mut self,
-        node: &mut ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_namespace_specifier(&mut self, node: &mut ExportNamespaceSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_export_namespace_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifier(
-        &mut self,
-        node: &mut ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_specifier(&mut self, node: &mut ExportSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_specifier(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_export_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_export_specifiers(
-        &mut self,
-        node: &mut Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_export_specifiers(&mut self, node: &mut Vec<ExportSpecifier>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_export_specifiers(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_export_specifiers(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_expr(&mut self, node: &mut Expr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_expr_or_spread(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_expr_or_spread(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_expr_or_spreads(&mut self, node: &mut Vec<ExprOrSpread>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_expr_or_spreads(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_expr_or_spreads(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_expr_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_expr_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_exprs(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_exprs(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_fn_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_fn_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_fn_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_fn_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_head(&mut self, node: &mut ForHead) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_for_head(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_for_head(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_for_in_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_for_in_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_for_of_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_for_of_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_for_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_for_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+    fn visit_mut_function(&mut self, node: &mut Function) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_function(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_function(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_getter_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_getter_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ident(&mut self, node: &mut Ident) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ident(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ident_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ident_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_if_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_if_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import(&mut self, node: &mut Import) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_default_specifier(
-        &mut self,
-        node: &mut ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_default_specifier(&mut self, node: &mut ImportDefaultSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_default_specifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_import_default_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_named_specifier(
-        &mut self,
-        node: &mut ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_named_specifier(&mut self, node: &mut ImportNamedSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_named_specifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_import_named_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_phase(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_phase(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifier(
-        &mut self,
-        node: &mut ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_specifier(&mut self, node: &mut ImportSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_specifier(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_specifiers(
-        &mut self,
-        node: &mut Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_specifiers(&mut self, node: &mut Vec<ImportSpecifier>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_specifiers(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_specifiers(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_star_as_specifier(
-        &mut self,
-        node: &mut ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_star_as_specifier(&mut self, node: &mut ImportStarAsSpecifier) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_import_star_as_specifier(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_with(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_with(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_item(
-        &mut self,
-        node: &mut ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_with_item(&mut self, node: &mut ImportWithItem) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_with_item(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_with_item(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_import_with_items(
-        &mut self,
-        node: &mut Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_import_with_items(&mut self, node: &mut Vec<ImportWithItem>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_import_with_items(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_import_with_items(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
+    fn visit_mut_invalid(&mut self, node: &mut Invalid) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_invalid(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_invalid(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_attr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_attr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_attr_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_attr_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spread(
-        &mut self,
-        node: &mut JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_attr_or_spread(&mut self, node: &mut JSXAttrOrSpread) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_attr_or_spread(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_or_spreads(
-        &mut self,
-        node: &mut Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_attr_or_spreads(&mut self, node: &mut Vec<JSXAttrOrSpread>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_attr_or_spreads(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_attr_value(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_attr_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_element(
-        &mut self,
-        node: &mut JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_closing_element(&mut self, node: &mut JSXClosingElement) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_closing_element(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_closing_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_closing_fragment(
-        &mut self,
-        node: &mut JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_closing_fragment(&mut self, node: &mut JSXClosingFragment) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_closing_fragment(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_element(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_child(
-        &mut self,
-        node: &mut JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_element_child(&mut self, node: &mut JSXElementChild) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_element_child(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_element_child(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_childs(
-        &mut self,
-        node: &mut Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_element_childs(&mut self, node: &mut Vec<JSXElementChild>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_element_childs(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_element_childs(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_element_name(
-        &mut self,
-        node: &mut JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_element_name(&mut self, node: &mut JSXElementName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_element_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_element_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_empty_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_expr_container(
-        &mut self,
-        node: &mut JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_expr_container(&mut self, node: &mut JSXExprContainer) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_expr_container(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_expr_container(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_fragment(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_fragment(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_member_expr(
-        &mut self,
-        node: &mut JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_member_expr(&mut self, node: &mut JSXMemberExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_member_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_member_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_namespaced_name(
-        &mut self,
-        node: &mut JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_namespaced_name(&mut self, node: &mut JSXNamespacedName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_namespaced_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_object(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_object(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_element(
-        &mut self,
-        node: &mut JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_opening_element(&mut self, node: &mut JSXOpeningElement) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_opening_element(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_opening_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_opening_fragment(
-        &mut self,
-        node: &mut JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_opening_fragment(&mut self, node: &mut JSXOpeningFragment) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_jsx_opening_fragment(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_spread_child(
-        &mut self,
-        node: &mut JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_jsx_spread_child(&mut self, node: &mut JSXSpreadChild) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_spread_child(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_spread_child(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_jsx_text(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_jsx_text(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
+    fn visit_mut_key(&mut self, node: &mut Key) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_key(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_key(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_pat_prop(
-        &mut self,
-        node: &mut KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_key_value_pat_prop(&mut self, node: &mut KeyValuePatProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_key_value_pat_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_key_value_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_key_value_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_labeled_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_labeled_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_lit(&mut self, node: &mut Lit) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_lit(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_lit(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_member_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_member_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_member_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_member_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_meta_prop_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_meta_prop_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_meta_prop_kind(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_meta_prop_kind(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_method_kind(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_method_kind(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_method_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_method_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module(&mut self, node: &mut Module) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_module(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_module(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_module_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_module_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_export_name(
-        &mut self,
-        node: &mut ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_module_export_name(&mut self, node: &mut ModuleExportName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_module_export_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_module_export_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_module_item(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_module_item(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_module_items(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_module_items(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_named_export(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_named_export(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_new_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_new_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
+    fn visit_mut_null(&mut self, node: &mut Null) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_null(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_null(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+    fn visit_mut_number(&mut self, node: &mut Number) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_number(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_number(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_object_lit(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_object_lit(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_object_pat(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_object_pat(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_prop(
-        &mut self,
-        node: &mut ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_object_pat_prop(&mut self, node: &mut ObjectPatProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_object_pat_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_object_pat_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_object_pat_props(
-        &mut self,
-        node: &mut Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_object_pat_props(&mut self, node: &mut Vec<ObjectPatProp>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_object_pat_props(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_object_pat_props(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_accessibility(
-        &mut self,
-        node: &mut Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_accessibility(&mut self, node: &mut Option<Accessibility>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_accessibility(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_accessibility(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_atom(
-        &mut self,
-        node: &mut Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_atom(&mut self, node: &mut Option<swc_atoms::Atom>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_atom(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_atom(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_block_stmt(
-        &mut self,
-        node: &mut Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_block_stmt(&mut self, node: &mut Option<BlockStmt>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_block_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_block_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_call(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_call(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_catch_clause(
-        &mut self,
-        node: &mut Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_catch_clause(&mut self, node: &mut Option<CatchClause>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_catch_clause(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_catch_clause(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_chain_base(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_chain_base(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_chain_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_chain_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spread(
-        &mut self,
-        node: &mut Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_expr_or_spread(&mut self, node: &mut Option<ExprOrSpread>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_expr_or_spread(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_expr_or_spreads(
-        &mut self,
-        node: &mut Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_expr_or_spreads(&mut self, node: &mut Option<Vec<ExprOrSpread>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_expr_or_spreads(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ident(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_attr_value(
-        &mut self,
-        node: &mut Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_jsx_attr_value(&mut self, node: &mut Option<JSXAttrValue>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_jsx_attr_value(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_jsx_closing_element(
-        &mut self,
-        node: &mut Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_jsx_closing_element(&mut self, node: &mut Option<JSXClosingElement>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_jsx_closing_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_module_export_name(
-        &mut self,
-        node: &mut Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_module_export_name(&mut self, node: &mut Option<ModuleExportName>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_module_export_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_module_export_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_object_lit(
-        &mut self,
-        node: &mut Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_object_lit(&mut self, node: &mut Option<Box<ObjectLit>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_object_lit(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_object_lit(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_pat(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_pat(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_span(
-        &mut self,
-        node: &mut Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_span(&mut self, node: &mut Option<swc_common::Span>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_span(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_span(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_str(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_str(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_true_plus_minus(
-        &mut self,
-        node: &mut Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_true_plus_minus(&mut self, node: &mut Option<TruePlusMinus>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_true_plus_minus(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_entity_name(
-        &mut self,
-        node: &mut Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_entity_name(&mut self, node: &mut Option<TsEntityName>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_ts_entity_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_namespace_body(
-        &mut self,
-        node: &mut Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_namespace_body(&mut self, node: &mut Option<TsNamespaceBody>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_ts_namespace_body(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type(
-        &mut self,
-        node: &mut Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_type(&mut self, node: &mut Option<Box<TsType>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ts_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_ts_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_ann(
-        &mut self,
-        node: &mut Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_type_ann(&mut self, node: &mut Option<Box<TsTypeAnn>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_ts_type_ann(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_ts_type_param_decl(
-        &mut self,
-        node: &mut Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_ts_type_param_decl(&mut self, node: &mut Option<Box<TsTypeParamDecl>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_ts_type_param_decl(&mut self.visitor, node)
         } else {
         }
     }
@@ -79332,1524 +57310,1131 @@ where
     fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
         node: &mut Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_var_decl_or_expr(
-        &mut self,
-        node: &mut Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_var_decl_or_expr(&mut self, node: &mut Option<VarDeclOrExpr>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_var_decl_or_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_expr_or_spreads(
-        &mut self,
-        node: &mut Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_vec_expr_or_spreads(&mut self, node: &mut Vec<Option<ExprOrSpread>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_opt_vec_pats(
-        &mut self,
-        node: &mut Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_opt_vec_pats(&mut self, node: &mut Vec<Option<Pat>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_opt_vec_pats(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_opt_vec_pats(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
+    fn visit_mut_param(&mut self, node: &mut Param) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_param(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_param(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_prop(
-        &mut self,
-        node: &mut ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_param_or_ts_param_prop(&mut self, node: &mut ParamOrTsParamProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_param_or_ts_param_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_param_or_ts_param_props(
-        &mut self,
-        node: &mut Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_param_or_ts_param_props(&mut self, node: &mut Vec<ParamOrTsParamProp>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_param_or_ts_param_props(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_params(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_params(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_paren_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_paren_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_pat(&mut self, node: &mut Pat) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pat(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_pat(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_pats(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_pats(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_private_method(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_private_method(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_private_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_private_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_private_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_private_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
+    fn visit_mut_program(&mut self, node: &mut Program) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_program(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_program(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
+    fn visit_mut_prop(&mut self, node: &mut Prop) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_prop_name(&mut self, node: &mut PropName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_prop_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_prop_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_prop_or_spread(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_prop_or_spread(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_prop_or_spreads(
-        &mut self,
-        node: &mut Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_prop_or_spreads(&mut self, node: &mut Vec<PropOrSpread>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_prop_or_spreads(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_prop_or_spreads(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
+    fn visit_mut_regex(&mut self, node: &mut Regex) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_regex(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_regex(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_rest_pat(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_rest_pat(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_return_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_return_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
+    fn visit_mut_script(&mut self, node: &mut Script) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_script(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_script(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_seq_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_seq_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_setter_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_setter_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_simple_assign_target(
-        &mut self,
-        node: &mut SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_simple_assign_target(&mut self, node: &mut SimpleAssignTarget) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_simple_assign_target(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_simple_assign_target(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_span(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_span(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_spread_element(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_spread_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_static_block(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_static_block(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_stmt(&mut self, node: &mut Stmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_stmts(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_stmts(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+    fn visit_mut_str(&mut self, node: &mut Str) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_str(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_str(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
+    fn visit_mut_super(&mut self, node: &mut Super) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_super(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_super(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_super_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_super_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_super_prop_expr(
-        &mut self,
-        node: &mut SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_super_prop_expr(&mut self, node: &mut SuperPropExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_super_prop_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_super_prop_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_switch_case(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_switch_case(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_switch_cases(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_switch_cases(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_switch_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_switch_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_syntax_context(
-        &mut self,
-        node: &mut swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_syntax_context(&mut self, node: &mut swc_common::SyntaxContext) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_syntax_context(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_syntax_context(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_tagged_tpl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_tagged_tpl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_this_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_this_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_throw_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_throw_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_tpl(&mut self, node: &mut Tpl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_tpl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_tpl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_tpl_element(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_tpl_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_tpl_elements(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_tpl_elements(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_true_plus_minus(
-        &mut self,
-        node: &mut TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_true_plus_minus(&mut self, node: &mut TruePlusMinus) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_true_plus_minus(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_true_plus_minus(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_try_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_try_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_array_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_array_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_as_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_as_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_call_signature_decl(
-        &mut self,
-        node: &mut TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_call_signature_decl(&mut self, node: &mut TsCallSignatureDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_call_signature_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_conditional_type(
-        &mut self,
-        node: &mut TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_conditional_type(&mut self, node: &mut TsConditionalType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_conditional_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_conditional_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_const_assertion(
-        &mut self,
-        node: &mut TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_const_assertion(&mut self, node: &mut TsConstAssertion) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_const_assertion(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_const_assertion(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_construct_signature_decl(
-        &mut self,
-        node: &mut TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_construct_signature_decl(&mut self, node: &mut TsConstructSignatureDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_construct_signature_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_constructor_type(
-        &mut self,
-        node: &mut TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_constructor_type(&mut self, node: &mut TsConstructorType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_constructor_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_constructor_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_entity_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_entity_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_enum_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_enum_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_enum_member(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_enum_member(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_member_id(
-        &mut self,
-        node: &mut TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_enum_member_id(&mut self, node: &mut TsEnumMemberId) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_enum_member_id(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_enum_members(
-        &mut self,
-        node: &mut Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_enum_members(&mut self, node: &mut Vec<TsEnumMember>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_enum_members(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_enum_members(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_export_assignment(
-        &mut self,
-        node: &mut TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_export_assignment(&mut self, node: &mut TsExportAssignment) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_export_assignment(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_export_assignment(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_args(
-        &mut self,
-        node: &mut TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_expr_with_type_args(&mut self, node: &mut TsExprWithTypeArgs) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_expr_with_type_args(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_expr_with_type_argss(
-        &mut self,
-        node: &mut Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_expr_with_type_argss(&mut self, node: &mut Vec<TsExprWithTypeArgs>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_expr_with_type_argss(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_external_module_ref(
-        &mut self,
-        node: &mut TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_external_module_ref(&mut self, node: &mut TsExternalModuleRef) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_external_module_ref(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_or_constructor_type(
-        &mut self,
-        node: &mut TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_fn_or_constructor_type(&mut self, node: &mut TsFnOrConstructorType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_fn_param(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_fn_param(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_fn_params(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_fn_params(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_fn_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_fn_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_getter_signature(
-        &mut self,
-        node: &mut TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_getter_signature(&mut self, node: &mut TsGetterSignature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_getter_signature(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_getter_signature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_equals_decl(
-        &mut self,
-        node: &mut TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_import_equals_decl(&mut self, node: &mut TsImportEqualsDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_import_equals_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_import_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_import_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_index_signature(
-        &mut self,
-        node: &mut TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_index_signature(&mut self, node: &mut TsIndexSignature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_index_signature(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_index_signature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_indexed_access_type(
-        &mut self,
-        node: &mut TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_indexed_access_type(&mut self, node: &mut TsIndexedAccessType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_indexed_access_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_infer_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_infer_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_instantiation(
-        &mut self,
-        node: &mut TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_instantiation(&mut self, node: &mut TsInstantiation) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_instantiation(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_instantiation(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_body(
-        &mut self,
-        node: &mut TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_interface_body(&mut self, node: &mut TsInterfaceBody) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_interface_body(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_interface_body(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_interface_decl(
-        &mut self,
-        node: &mut TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_interface_decl(&mut self, node: &mut TsInterfaceDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_interface_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_interface_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_intersection_type(
-        &mut self,
-        node: &mut TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_intersection_type(&mut self, node: &mut TsIntersectionType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_intersection_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_intersection_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type(
-        &mut self,
-        node: &mut TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_keyword_type(&mut self, node: &mut TsKeywordType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_keyword_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_keyword_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_keyword_type_kind(
-        &mut self,
-        node: &mut TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_keyword_type_kind(&mut self, node: &mut TsKeywordTypeKind) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_keyword_type_kind(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_lit(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_lit(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_lit_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_lit_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_mapped_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_mapped_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_method_signature(
-        &mut self,
-        node: &mut TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_method_signature(&mut self, node: &mut TsMethodSignature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_method_signature(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_method_signature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_block(
-        &mut self,
-        node: &mut TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_module_block(&mut self, node: &mut TsModuleBlock) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_module_block(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_module_block(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_module_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_module_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_module_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_module_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_module_ref(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_module_ref(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_body(
-        &mut self,
-        node: &mut TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_namespace_body(&mut self, node: &mut TsNamespaceBody) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_namespace_body(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_namespace_body(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_decl(
-        &mut self,
-        node: &mut TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_namespace_decl(&mut self, node: &mut TsNamespaceDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_namespace_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_namespace_export_decl(
-        &mut self,
-        node: &mut TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_namespace_export_decl(&mut self, node: &mut TsNamespaceExportDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_namespace_export_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_non_null_expr(
-        &mut self,
-        node: &mut TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_non_null_expr(&mut self, node: &mut TsNonNullExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_non_null_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_optional_type(
-        &mut self,
-        node: &mut TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_optional_type(&mut self, node: &mut TsOptionalType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_optional_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_optional_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_param_prop(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_param_prop(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_param_prop_param(
-        &mut self,
-        node: &mut TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_param_prop_param(&mut self, node: &mut TsParamPropParam) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_param_prop_param(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_parenthesized_type(
-        &mut self,
-        node: &mut TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_parenthesized_type(&mut self, node: &mut TsParenthesizedType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_parenthesized_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_property_signature(
-        &mut self,
-        node: &mut TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_property_signature(&mut self, node: &mut TsPropertySignature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_property_signature(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_property_signature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_qualified_name(
-        &mut self,
-        node: &mut TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_qualified_name(&mut self, node: &mut TsQualifiedName) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_qualified_name(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_qualified_name(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_rest_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_rest_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_satisfies_expr(
-        &mut self,
-        node: &mut TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_satisfies_expr(&mut self, node: &mut TsSatisfiesExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_satisfies_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_setter_signature(
-        &mut self,
-        node: &mut TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_setter_signature(&mut self, node: &mut TsSetterSignature) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_setter_signature(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_setter_signature(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_this_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_this_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_this_type_or_ident(
-        &mut self,
-        node: &mut TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_this_type_or_ident(&mut self, node: &mut TsThisTypeOrIdent) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_this_type_or_ident(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_tpl_lit_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_element(
-        &mut self,
-        node: &mut TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_tuple_element(&mut self, node: &mut TsTupleElement) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_tuple_element(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_tuple_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_elements(
-        &mut self,
-        node: &mut Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_tuple_elements(&mut self, node: &mut Vec<TsTupleElement>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_tuple_elements(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_tuple_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_tuple_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type(&mut self, node: &mut TsType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_alias_decl(
-        &mut self,
-        node: &mut TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_alias_decl(&mut self, node: &mut TsTypeAliasDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_type_alias_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_ann(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_ann(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_assertion(
-        &mut self,
-        node: &mut TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_assertion(&mut self, node: &mut TsTypeAssertion) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_assertion(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_assertion(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_element(
-        &mut self,
-        node: &mut TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_element(&mut self, node: &mut TsTypeElement) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_element(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_element(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_elements(
-        &mut self,
-        node: &mut Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_elements(&mut self, node: &mut Vec<TsTypeElement>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_elements(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_elements(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_lit(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_lit(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator(
-        &mut self,
-        node: &mut TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_operator(&mut self, node: &mut TsTypeOperator) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_operator(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_operator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_operator_op(
-        &mut self,
-        node: &mut TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_operator_op(&mut self, node: &mut TsTypeOperatorOp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_type_operator_op(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_param(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_param(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_decl(
-        &mut self,
-        node: &mut TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_param_decl(&mut self, node: &mut TsTypeParamDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_type_param_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_param_instantiation(
-        &mut self,
-        node: &mut TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_param_instantiation(&mut self, node: &mut TsTypeParamInstantiation) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_type_param_instantiation(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_params(
-        &mut self,
-        node: &mut Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_params(&mut self, node: &mut Vec<TsTypeParam>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_params(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_params(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_predicate(
-        &mut self,
-        node: &mut TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_predicate(&mut self, node: &mut TsTypePredicate) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_predicate(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_predicate(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_query(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_query(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_query_expr(
-        &mut self,
-        node: &mut TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_type_query_expr(&mut self, node: &mut TsTypeQueryExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_type_query_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_type_ref(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_type_ref(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_types(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_types(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_or_intersection_type(
-        &mut self,
-        node: &mut TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_ts_union_or_intersection_type(&mut self, node: &mut TsUnionOrIntersectionType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as VisitMut>::visit_mut_ts_union_or_intersection_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_ts_union_type(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_ts_union_type(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_unary_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_unary_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_unary_op(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_unary_op(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_update_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_update_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_update_op(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_update_op(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_using_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_using_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_var_decl(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_var_decl(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_var_decl_kind(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_var_decl_kind(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_decl_or_expr(
-        &mut self,
-        node: &mut VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_var_decl_or_expr(&mut self, node: &mut VarDeclOrExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_var_decl_or_expr(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_var_declarator(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_var_declarator(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_var_declarators(
-        &mut self,
-        node: &mut Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) {
+    fn visit_mut_var_declarators(&mut self, node: &mut Vec<VarDeclarator>) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_var_declarators(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_var_declarators(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_while_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_while_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_with_stmt(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_with_stmt(&mut self.visitor, node)
         } else {
         }
     }
 
     #[inline]
-    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
         if self.enabled {
-            <V as VisitMutAstPath>::visit_mut_yield_expr(&mut self.visitor, node, __ast_path)
+            <V as VisitMut>::visit_mut_yield_expr(&mut self.visitor, node)
         } else {
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait VisitMutWithAstPath<V: ?Sized + VisitMutAstPath> {
+pub trait VisitMutWith<V: ?Sized + VisitMut> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
+    fn visit_mut_with(&mut self, visitor: &mut V);
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
+    fn visit_mut_children_with(&mut self, visitor: &mut V);
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Accessibility {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_accessibility`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_accessibility(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Accessibility {
+    #[doc = "Calls [VisitMut`::visit_mut_accessibility`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_accessibility(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Accessibility::Public => {}
             Accessibility::Protected => {}
@@ -80857,49 +58442,32 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Accessibility {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrayLit {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_array_lit`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_array_lit(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrayLit {
+    #[doc = "Calls [VisitMut`::visit_mut_array_lit`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_array_lit(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ArrayLit { span, elems } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrayLit(self::fields::ArrayLitField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayLit(
-                        self::fields::ArrayLitField::Elems(usize::MAX),
-                    ));
-                    <Vec<Option<ExprOrSpread>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        elems,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Option<ExprOrSpread>> as VisitMutWith<V>>::visit_mut_with(elems, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrayPat {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_array_pat`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_array_pat(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrayPat {
+    #[doc = "Calls [VisitMut`::visit_mut_array_pat`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_array_pat(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ArrayPat {
                 span,
@@ -80908,47 +58476,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrayPat {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrayPat(self::fields::ArrayPatField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
-                        self::fields::ArrayPatField::Elems(usize::MAX),
-                    ));
-                    <Vec<Option<Pat>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        elems,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Option<Pat>> as VisitMutWith<V>>::visit_mut_with(elems, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
-                        self::fields::ArrayPatField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrowExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_arrow_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_arrow_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ArrowExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_arrow_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_arrow_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ArrowExpr {
                 span,
@@ -80961,71 +58507,40 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrowExpr {
                 return_type,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
-                        self::fields::ArrowExprField::Params(usize::MAX),
-                    ));
-                    <Vec<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Pat> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Body));
-                    <Box<BlockStmtOrExpr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<BlockStmtOrExpr> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
-                        self::fields::ArrowExprField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
+                        visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
-                        self::fields::ArrowExprField::ReturnType,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(
                         return_type,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_assign_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_assign_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AssignExpr {
                 span,
@@ -81033,58 +58548,29 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignExpr {
                 left,
                 right,
             } => {
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
-                        self::fields::AssignExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                {
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AssignExpr(self::fields::AssignExprField::Op));
-                    <AssignOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <AssignOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
-                        self::fields::AssignExprField::Left,
-                    ));
-                    <AssignTarget as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <AssignTarget as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
-                        self::fields::AssignExprField::Right,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignOp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_op`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_op(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignOp {
+    #[doc = "Calls [VisitMut`::visit_mut_assign_op`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_assign_op(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AssignOp::Assign => {}
             AssignOp::AddAssign => {}
@@ -81105,224 +58591,116 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignPat {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_pat`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_pat(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignPat {
+    #[doc = "Calls [VisitMut`::visit_mut_assign_pat`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_assign_pat(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AssignPat { span, left, right } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Left));
-                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPat(
-                        self::fields::AssignPatField::Right,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignPatProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_pat_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignPatProp {
+    #[doc = "Calls [VisitMut`::visit_mut_assign_pat_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_assign_pat_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AssignPatProp { span, key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
-                        self::fields::AssignPatPropField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
-                        self::fields::AssignPatPropField::Key,
-                    ));
-                    <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BindingIdent as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
-                        self::fields::AssignPatPropField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignProp {
+    #[doc = "Calls [VisitMut`::visit_mut_assign_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_assign_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AssignProp { span, key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
-                        self::fields::AssignPropField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
-                        self::fields::AssignPropField::Key,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
-                        self::fields::AssignPropField::Value,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignTarget {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_target`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_target(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignTarget {
+    #[doc = "Calls [VisitMut`::visit_mut_assign_target`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_assign_target(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AssignTarget::Simple { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
-                    self::fields::AssignTargetField::Simple,
-                ));
-                <SimpleAssignTarget as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SimpleAssignTarget as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AssignTarget::Pat { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
-                    self::fields::AssignTargetField::Pat,
-                ));
-                <AssignTargetPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignTargetPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignTargetPat {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_target_pat`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_assign_target_pat(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AssignTargetPat {
+    #[doc = "Calls [VisitMut`::visit_mut_assign_target_pat`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_assign_target_pat(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AssignTargetPat::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
-                    self::fields::AssignTargetPatField::Array,
-                ));
-                <ArrayPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AssignTargetPat::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
-                    self::fields::AssignTargetPatField::Object,
-                ));
-                <ObjectPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             AssignTargetPat::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
-                    self::fields::AssignTargetPatField::Invalid,
-                ));
-                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AutoAccessor {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_auto_accessor`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_auto_accessor(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AutoAccessor {
+    #[doc = "Calls [VisitMut`::visit_mut_auto_accessor`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_auto_accessor(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AutoAccessor {
                 span,
@@ -81337,153 +58715,78 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AutoAccessor {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Key,
-                    ));
-                    <Key as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Key as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
                         accessibility,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AwaitExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_await_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_await_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for AwaitExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_await_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_await_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             AwaitExpr { span, arg } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Arg));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BigInt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_big_int`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_big_int(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BigInt {
+    #[doc = "Calls [VisitMut`::visit_mut_big_int`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_big_int(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BigInt { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Value));
-                    <Box<BigIntValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<BigIntValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_bin_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bin_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_bin_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_bin_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BinExpr {
                 span,
@@ -81492,54 +58795,28 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinExpr {
                 right,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Op));
-                    <BinaryOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BinaryOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Left));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Right));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinaryOp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_binary_op`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_binary_op(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BinaryOp {
+    #[doc = "Calls [VisitMut`::visit_mut_binary_op`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_binary_op(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BinaryOp::EqEq => {}
             BinaryOp::NotEq => {}
@@ -81569,184 +58846,106 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinaryOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BindingIdent {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_binding_ident`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_binding_ident(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BindingIdent {
+    #[doc = "Calls [VisitMut`::visit_mut_binding_ident`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_binding_ident(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BindingIdent { id, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
-                        self::fields::BindingIdentField::Id,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
-                        self::fields::BindingIdentField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BlockStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_block_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_block_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BlockStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_block_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_block_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BlockStmt { span, ctxt, stmts } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmt(
-                        self::fields::BlockStmtField::Stmts(usize::MAX),
-                    ));
-                    <Vec<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        stmts,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Stmt> as VisitMutWith<V>>::visit_mut_with(stmts, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BlockStmtOrExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_block_stmt_or_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BlockStmtOrExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_block_stmt_or_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_block_stmt_or_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BlockStmtOrExpr::BlockStmt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
-                    self::fields::BlockStmtOrExprField::BlockStmt,
-                ));
-                <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BlockStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             BlockStmtOrExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
-                    self::fields::BlockStmtOrExprField::Expr,
-                ));
-                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Bool {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_bool`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_bool(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Bool {
+    #[doc = "Calls [VisitMut`::visit_mut_bool`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_bool(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Bool { span, value } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Bool(self::fields::BoolField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BreakStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_break_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_break_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BreakStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_break_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_break_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             BreakStmt { span, label } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BreakStmt(self::fields::BreakStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BreakStmt(
-                        self::fields::BreakStmtField::Label,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(label, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CallExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_call_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_call_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CallExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_call_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_call_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CallExpr {
                 span,
@@ -81756,146 +58955,75 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CallExpr {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Callee));
-                    <Callee as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Callee as VisitMutWith<V>>::visit_mut_with(callee, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
-                        self::fields::CallExprField::Args(usize::MAX),
-                    ));
-                    <Vec<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(args, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
-                        self::fields::CallExprField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Callee {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_callee`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_callee(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Callee {
+    #[doc = "Calls [VisitMut`::visit_mut_callee`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_callee(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Callee::Super { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Super));
-                <Super as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Super as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Callee::Import { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Import));
-                <Import as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Import as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Callee::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Expr));
-                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CatchClause {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_catch_clause`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_catch_clause(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CatchClause {
+    #[doc = "Calls [VisitMut`::visit_mut_catch_clause`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_catch_clause(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CatchClause { span, param, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
-                        self::fields::CatchClauseField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
-                        self::fields::CatchClauseField::Param,
-                    ));
-                    <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Pat> as VisitMutWith<V>>::visit_mut_with(param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
-                        self::fields::CatchClauseField::Body,
-                    ));
-                    <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BlockStmt as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Class {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Class {
+    #[doc = "Calls [VisitMut`::visit_mut_class`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Class {
                 span,
@@ -81909,86 +59037,48 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Class {
                 implements,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::Body(usize::MAX),
-                    ));
-                    <Vec<ClassMember> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ClassMember> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Class(self::fields::ClassField::SuperClass));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        super_class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(super_class, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Class(self::fields::ClassField::TypeParams));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
+                        visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::SuperTypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (super_type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        super_type_params,
+                        visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::Implements(usize::MAX),
-                    ));
-                    <Vec<TsExprWithTypeArgs> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        implements,
-                        visitor,
-                        &mut *__ast_path,
+                    <Vec<TsExprWithTypeArgs> as VisitMutWith<V>>::visit_mut_with(
+                        implements, visitor,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_class_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ClassDecl {
                 ident,
@@ -81996,176 +59086,79 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassDecl {
                 class,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
-                        self::fields::ClassDeclField::Ident,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
-                        self::fields::ClassDeclField::Class,
-                    ));
-                    <Box<Class> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Class> as VisitMutWith<V>>::visit_mut_with(class, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_class_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ClassExpr { ident, class } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
-                        self::fields::ClassExprField::Ident,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
-                        self::fields::ClassExprField::Class,
-                    ));
-                    <Box<Class> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Class> as VisitMutWith<V>>::visit_mut_with(class, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassMember {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_member`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_member(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassMember {
+    #[doc = "Calls [VisitMut`::visit_mut_class_member`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class_member(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ClassMember::Constructor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::Constructor,
-                ));
-                <Constructor as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Constructor as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::Method { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::Method,
-                ));
-                <ClassMethod as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassMethod as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::PrivateMethod { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::PrivateMethod,
-                ));
-                <PrivateMethod as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateMethod as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::ClassProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::ClassProp,
-                ));
-                <ClassProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::PrivateProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::PrivateProp,
-                ));
-                <PrivateProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::TsIndexSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::TsIndexSignature,
-                ));
-                <TsIndexSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIndexSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::Empty { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::Empty,
-                ));
-                <EmptyStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <EmptyStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::StaticBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::StaticBlock,
-                ));
-                <StaticBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <StaticBlock as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ClassMember::AutoAccessor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::AutoAccessor,
-                ));
-                <AutoAccessor as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AutoAccessor as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassMethod {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_method`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_method(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassMethod {
+    #[doc = "Calls [VisitMut`::visit_mut_class_method`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class_method(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ClassMethod {
                 span,
@@ -82179,68 +59172,34 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassMethod {
                 is_override,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Key,
-                    ));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Function,
-                    ));
-                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Kind,
-                    ));
-                    <MethodKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MethodKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
                         accessibility,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ClassProp {
+    #[doc = "Calls [VisitMut`::visit_mut_class_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ClassProp {
                 span,
@@ -82258,111 +59217,56 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassProp {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Key));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
                         accessibility,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComputedPropName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_computed_prop_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_computed_prop_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ComputedPropName {
+    #[doc = "Calls [VisitMut`::visit_mut_computed_prop_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_computed_prop_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ComputedPropName { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
-                        self::fields::ComputedPropNameField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
-                        self::fields::ComputedPropNameField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CondExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_cond_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_cond_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for CondExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_cond_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_cond_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             CondExpr {
                 span,
@@ -82371,54 +59275,28 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CondExpr {
                 alt,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Test));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Cons));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(cons, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Alt));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        alt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(alt, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Constructor {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_constructor`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_constructor(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Constructor {
+    #[doc = "Calls [VisitMut`::visit_mut_constructor`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_constructor(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Constructor {
                 span,
@@ -82430,368 +59308,184 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Constructor {
                 is_optional,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Key,
-                    ));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Params(usize::MAX),
-                    ));
-                    <Vec<ParamOrTsParamProp> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ParamOrTsParamProp> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Body,
-                    ));
-                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
                         accessibility,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContinueStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_continue_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_continue_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ContinueStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_continue_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_continue_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ContinueStmt { span, label } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
-                        self::fields::ContinueStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
-                        self::fields::ContinueStmtField::Label,
-                    ));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(label, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DebuggerStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_debugger_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_debugger_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DebuggerStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_debugger_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_debugger_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DebuggerStmt { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DebuggerStmt(
-                        self::fields::DebuggerStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Decl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Decl {
+    #[doc = "Calls [VisitMut`::visit_mut_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Decl::Class { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Class));
-                <ClassDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Decl::Fn { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Fn));
-                <FnDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FnDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Decl::Var { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Var));
-                <Box<VarDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<VarDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Decl::Using { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Using));
-                <Box<UsingDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<UsingDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Decl::TsInterface { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsInterface));
-                <Box<TsInterfaceDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsInterfaceDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Decl::TsTypeAlias { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsTypeAlias));
-                <Box<TsTypeAliasDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsTypeAliasDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Decl::TsEnum { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsEnum));
-                <Box<TsEnumDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsEnumDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Decl::TsModule { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsModule));
-                <Box<TsModuleDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsModuleDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Decorator {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_decorator`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decorator(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Decorator {
+    #[doc = "Calls [VisitMut`::visit_mut_decorator`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_decorator(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Decorator { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Expr));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DefaultDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_default_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_default_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DefaultDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_default_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_default_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DefaultDecl::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
-                    self::fields::DefaultDeclField::Class,
-                ));
-                <ClassExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             DefaultDecl::Fn { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
-                    self::fields::DefaultDeclField::Fn,
-                ));
-                <FnExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FnExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             DefaultDecl::TsInterfaceDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
-                    self::fields::DefaultDeclField::TsInterfaceDecl,
-                ));
-                <Box<TsInterfaceDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsInterfaceDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DoWhileStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_do_while_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_do_while_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for DoWhileStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_do_while_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_do_while_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             DoWhileStmt { span, test, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
-                        self::fields::DoWhileStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
-                        self::fields::DoWhileStmtField::Test,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
-                        self::fields::DoWhileStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for EmptyStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_empty_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_empty_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for EmptyStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_empty_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_empty_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             EmptyStmt { span } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::EmptyStmt(self::fields::EmptyStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for EsVersion {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_es_version`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_es_version(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for EsVersion {
+    #[doc = "Calls [VisitMut`::visit_mut_es_version`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_es_version(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             EsVersion::Es3 => {}
             EsVersion::Es5 => {}
@@ -82807,15 +59501,13 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for EsVersion {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportAll {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_all`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_all(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportAll {
+    #[doc = "Calls [VisitMut`::visit_mut_export_all`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_all(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportAll {
                 span,
@@ -82824,176 +59516,98 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportAll {
                 with,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Src));
-                    <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Str> as VisitMutWith<V>>::visit_mut_with(src, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::With));
-                    <Option<Box<ObjectLit>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ObjectLit>> as VisitMutWith<V>>::visit_mut_with(with, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_export_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportDecl { span, decl } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
-                        self::fields::ExportDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
-                        self::fields::ExportDeclField::Decl,
-                    ));
-                    <Decl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decl,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Decl as VisitMutWith<V>>::visit_mut_with(decl, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDefaultDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_default_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_default_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDefaultDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_export_default_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_default_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportDefaultDecl { span, decl } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
-                        self::fields::ExportDefaultDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
-                        self::fields::ExportDefaultDeclField::Decl,
-                    ));
-                    <DefaultDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decl,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <DefaultDecl as VisitMutWith<V>>::visit_mut_with(decl, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDefaultExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_default_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_default_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDefaultExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_export_default_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_default_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportDefaultExpr { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
-                        self::fields::ExportDefaultExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
-                        self::fields::ExportDefaultExprField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDefaultSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_default_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_default_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportDefaultSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_export_default_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_default_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportDefaultSpecifier { exported } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportDefaultSpecifier(
-                            self::fields::ExportDefaultSpecifierField::Exported,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        exported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(exported, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportNamedSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_named_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_named_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportNamedSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_export_named_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_named_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportNamedSpecifier {
                 span,
@@ -83002,558 +59616,227 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportNamedSpecifie
                 is_type_only,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
-                            self::fields::ExportNamedSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
-                            self::fields::ExportNamedSpecifierField::Orig,
-                        ));
-                    <ModuleExportName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        orig,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ModuleExportName as VisitMutWith<V>>::visit_mut_with(orig, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
-                            self::fields::ExportNamedSpecifierField::Exported,
-                        ));
-                    <Option<ModuleExportName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        exported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ModuleExportName> as VisitMutWith<V>>::visit_mut_with(exported, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportNamespaceSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_namespace_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportNamespaceSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_export_namespace_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_namespace_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportNamespaceSpecifier { span, name } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
-                            self::fields::ExportNamespaceSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
-                            self::fields::ExportNamespaceSpecifierField::Name,
-                        ));
-                    <ModuleExportName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ModuleExportName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExportSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_export_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExportSpecifier::Namespace { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
-                    self::fields::ExportSpecifierField::Namespace,
-                ));
-                <ExportNamespaceSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportNamespaceSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ExportSpecifier::Default { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
-                    self::fields::ExportSpecifierField::Default,
-                ));
-                <ExportDefaultSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDefaultSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ExportSpecifier::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
-                    self::fields::ExportSpecifierField::Named,
-                ));
-                <ExportNamedSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportNamedSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Expr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Expr {
+    #[doc = "Calls [VisitMut`::visit_mut_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Expr::This { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::This));
-                <ThisExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ThisExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Array { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Array));
-                <ArrayLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayLit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Object { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Object));
-                <ObjectLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectLit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Fn { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Fn));
-                <FnExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <FnExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Unary { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Unary));
-                <UnaryExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UnaryExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Update { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Update));
-                <UpdateExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <UpdateExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Bin { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Bin));
-                <BinExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BinExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Assign { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Assign));
-                <AssignExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Member { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Member));
-                <MemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::SuperProp { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::SuperProp));
-                <SuperPropExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SuperPropExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Cond { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Cond));
-                <CondExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CondExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Call { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Call));
-                <CallExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <CallExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::New { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::New));
-                <NewExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NewExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Seq { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Seq));
-                <SeqExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SeqExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Ident));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Lit { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Lit));
-                <Lit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Lit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Tpl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Tpl));
-                <Tpl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Tpl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::TaggedTpl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TaggedTpl));
-                <TaggedTpl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TaggedTpl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Arrow { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Arrow));
-                <ArrowExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrowExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Class { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Class));
-                <ClassExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ClassExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Yield { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Yield));
-                <YieldExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <YieldExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::MetaProp { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::MetaProp));
-                <MetaPropExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MetaPropExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Await { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Await));
-                <AwaitExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AwaitExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Paren { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Paren));
-                <ParenExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ParenExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::JSXMember { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxmember));
-                <JSXMemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXMemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::JsxnamespacedName,
-                ));
-                <JSXNamespacedName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXNamespacedName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::JSXEmpty { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxempty));
-                <JSXEmptyExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXEmptyExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::JSXElement { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxelement));
-                <Box<JSXElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXElement> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxfragment));
-                <JSXFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXFragment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::TsTypeAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::TsTypeAssertion,
-                ));
-                <TsTypeAssertion as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeAssertion as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::TsConstAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::TsConstAssertion,
-                ));
-                <TsConstAssertion as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConstAssertion as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::TsNonNull { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsNonNull));
-                <TsNonNullExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNonNullExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::TsAs { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsAs));
-                <TsAsExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsAsExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::TsInstantiation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::TsInstantiation,
-                ));
-                <TsInstantiation as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsInstantiation as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::TsSatisfies { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Expr(self::fields::ExprField::TsSatisfies));
-                <TsSatisfiesExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsSatisfiesExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::PrivateName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Expr(self::fields::ExprField::PrivateName));
-                <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::OptChain { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::OptChain));
-                <OptChainExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <OptChainExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Expr::Invalid { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Invalid));
-                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExprOrSpread {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr_or_spread`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExprOrSpread {
+    #[doc = "Calls [VisitMut`::visit_mut_expr_or_spread`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_expr_or_spread(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExprOrSpread { spread, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
-                        self::fields::ExprOrSpreadField::Spread,
-                    ));
-                    <Option<swc_common::Span> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        spread,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_common::Span> as VisitMutWith<V>>::visit_mut_with(spread, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
-                        self::fields::ExprOrSpreadField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExprStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ExprStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_expr_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_expr_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ExprStmt { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Expr));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FnDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_fn_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_fn_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for FnDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_fn_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_fn_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             FnDecl {
                 ident,
@@ -83561,110 +59844,61 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FnDecl {
                 function,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Ident));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Function));
-                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FnExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_fn_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_fn_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for FnExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_fn_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_fn_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             FnExpr { ident, function } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Ident));
-                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Ident> as VisitMutWith<V>>::visit_mut_with(ident, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Function));
-                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForHead {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_head`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_head(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForHead {
+    #[doc = "Calls [VisitMut`::visit_mut_for_head`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_for_head(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForHead::VarDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::ForHead(self::fields::ForHeadField::VarDecl));
-                <Box<VarDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<VarDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ForHead::UsingDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ForHead(
-                    self::fields::ForHeadField::UsingDecl,
-                ));
-                <Box<UsingDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<UsingDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ForHead::Pat { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForHead(self::fields::ForHeadField::Pat));
-                <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Pat> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForInStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_in_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_in_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForInStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_for_in_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_for_in_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForInStmt {
                 span,
@@ -83673,55 +59907,28 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForInStmt {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Left));
-                    <ForHead as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ForHead as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForInStmt(
-                        self::fields::ForInStmtField::Right,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Body));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForOfStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_of_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_of_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForOfStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_for_of_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_for_of_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForOfStmt {
                 span,
@@ -83731,55 +59938,28 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForOfStmt {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Left));
-                    <ForHead as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ForHead as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForOfStmt(
-                        self::fields::ForOfStmtField::Right,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Body));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_for_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ForStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_for_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_for_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ForStmt {
                 span,
@@ -83789,63 +59969,31 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForStmt {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Init));
-                    <Option<VarDeclOrExpr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<VarDeclOrExpr> as VisitMutWith<V>>::visit_mut_with(init, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Test));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Update));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        update,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(update, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Body));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Function {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_function`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_function(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Function {
+    #[doc = "Calls [VisitMut`::visit_mut_function`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_function(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Function {
                 params,
@@ -83859,81 +60007,43 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Function {
                 return_type,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::Params(usize::MAX),
-                    ));
-                    <Vec<Param> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Param> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Body));
-                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
+                        visitor,
+                    )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::ReturnType,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(
                         return_type,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for GetterProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_getter_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_getter_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for GetterProp {
+    #[doc = "Calls [VisitMut`::visit_mut_getter_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_getter_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             GetterProp {
                 span,
@@ -83942,58 +60052,28 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for GetterProp {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::Key,
-                    ));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::Body,
-                    ));
-                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Ident {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ident`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Ident {
+    #[doc = "Calls [VisitMut`::visit_mut_ident`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ident(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Ident {
                 span,
@@ -84002,78 +60082,44 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Ident {
                 optional,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Sym));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        sym,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(sym, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for IdentName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ident_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ident_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for IdentName {
+    #[doc = "Calls [VisitMut`::visit_mut_ident_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ident_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             IdentName { span, sym } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Sym));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        sym,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(sym, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for IfStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_if_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_if_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for IfStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_if_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_if_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             IfStmt {
                 span,
@@ -84082,87 +60128,47 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for IfStmt {
                 alt,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Test));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Cons));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(cons, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Alt));
-                    <Option<Box<Stmt>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        alt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Stmt>> as VisitMutWith<V>>::visit_mut_with(alt, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Import {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Import {
+    #[doc = "Calls [VisitMut`::visit_mut_import`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Import { span, phase } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Import(self::fields::ImportField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Import(self::fields::ImportField::Phase));
-                    <ImportPhase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        phase,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ImportPhase as VisitMutWith<V>>::visit_mut_with(phase, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_import_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportDecl {
                 span,
@@ -84173,105 +60179,50 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportDecl {
                 phase,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Specifiers(usize::MAX),
-                    ));
-                    <Vec<ImportSpecifier> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        specifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ImportSpecifier> as VisitMutWith<V>>::visit_mut_with(specifiers, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Src,
-                    ));
-                    <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Str> as VisitMutWith<V>>::visit_mut_with(src, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::With,
-                    ));
-                    <Option<Box<ObjectLit>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ObjectLit>> as VisitMutWith<V>>::visit_mut_with(with, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Phase,
-                    ));
-                    <ImportPhase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        phase,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <ImportPhase as VisitMutWith<V>>::visit_mut_with(phase, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportDefaultSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_default_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_default_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportDefaultSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_import_default_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_default_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportDefaultSpecifier { span, local } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
-                            self::fields::ImportDefaultSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
-                            self::fields::ImportDefaultSpecifierField::Local,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(local, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportNamedSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_named_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_named_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportNamedSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_import_named_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_named_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportNamedSpecifier {
                 span,
@@ -84280,51 +60231,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportNamedSpecifie
                 is_type_only,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
-                            self::fields::ImportNamedSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
-                            self::fields::ImportNamedSpecifierField::Local,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(local, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
-                            self::fields::ImportNamedSpecifierField::Imported,
-                        ));
-                    <Option<ModuleExportName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        imported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<ModuleExportName> as VisitMutWith<V>>::visit_mut_with(imported, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportPhase {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_phase`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_phase(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportPhase {
+    #[doc = "Calls [VisitMut`::visit_mut_import_phase`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_phase(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportPhase::Evaluation => {}
             ImportPhase::Source => {}
@@ -84332,410 +60257,220 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportPhase {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_import_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportSpecifier::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
-                    self::fields::ImportSpecifierField::Named,
-                ));
-                <ImportNamedSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportNamedSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ImportSpecifier::Default { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
-                    self::fields::ImportSpecifierField::Default,
-                ));
-                <ImportDefaultSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportDefaultSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ImportSpecifier::Namespace { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
-                    self::fields::ImportSpecifierField::Namespace,
-                ));
-                <ImportStarAsSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportStarAsSpecifier as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportStarAsSpecifier {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_star_as_specifier`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportStarAsSpecifier {
+    #[doc = "Calls [VisitMut`::visit_mut_import_star_as_specifier`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_star_as_specifier(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportStarAsSpecifier { span, local } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
-                            self::fields::ImportStarAsSpecifierField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
-                            self::fields::ImportStarAsSpecifierField::Local,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(local, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportWith {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_with`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_with(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportWith {
+    #[doc = "Calls [VisitMut`::visit_mut_import_with`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_with(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportWith { span, values } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
-                        self::fields::ImportWithField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
-                        self::fields::ImportWithField::Values(usize::MAX),
-                    ));
-                    <Vec<ImportWithItem> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        values,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ImportWithItem> as VisitMutWith<V>>::visit_mut_with(values, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportWithItem {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_with_item`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_with_item(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ImportWithItem {
+    #[doc = "Calls [VisitMut`::visit_mut_import_with_item`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_with_item(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ImportWithItem { key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
-                        self::fields::ImportWithItemField::Key,
-                    ));
-                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
-                        self::fields::ImportWithItemField::Value,
-                    ));
-                    <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Str as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Invalid {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_invalid`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_invalid(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Invalid {
+    #[doc = "Calls [VisitMut`::visit_mut_invalid`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_invalid(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Invalid { span } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Invalid(self::fields::InvalidField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttr {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_attr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXAttr { span, name, value } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Name));
-                    <JSXAttrName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXAttrName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Value));
-                    <Option<JSXAttrValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<JSXAttrValue> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttrName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttrName {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_attr_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXAttrName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
-                    self::fields::JSXAttrNameField::Ident,
-                ));
-                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXAttrName::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
-                    self::fields::JSXAttrNameField::JsxnamespacedName,
-                ));
-                <JSXNamespacedName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXNamespacedName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttrOrSpread {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_or_spread`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttrOrSpread {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_or_spread`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_attr_or_spread(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
-                    self::fields::JSXAttrOrSpreadField::Jsxattr,
-                ));
-                <JSXAttr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXAttr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
-                    self::fields::JSXAttrOrSpreadField::SpreadElement,
-                ));
-                <SpreadElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SpreadElement as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttrValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_value`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_value(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXAttrValue {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_value`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_attr_value(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXAttrValue::Lit { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::Lit,
-                ));
-                <Lit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Lit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXAttrValue::JSXExprContainer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::JsxexprContainer,
-                ));
-                <JSXExprContainer as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXExprContainer as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXAttrValue::JSXElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::Jsxelement,
-                ));
-                <Box<JSXElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXElement> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXAttrValue::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::Jsxfragment,
-                ));
-                <JSXFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXFragment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXClosingElement {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_closing_element`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_closing_element(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXClosingElement {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_closing_element`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_closing_element(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXClosingElement { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
-                        self::fields::JSXClosingElementField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
-                        self::fields::JSXClosingElementField::Name,
-                    ));
-                    <JSXElementName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXElementName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXClosingFragment {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_closing_fragment`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXClosingFragment {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_closing_fragment`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_closing_fragment(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXClosingFragment { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingFragment(
-                        self::fields::JSXClosingFragmentField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXElement {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXElement {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_element`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_element(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXElement {
                 span,
@@ -84744,256 +60479,126 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXElement {
                 closing,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Opening,
-                    ));
-                    <JSXOpeningElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        opening,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXOpeningElement as VisitMutWith<V>>::visit_mut_with(opening, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Children(usize::MAX),
-                    ));
-                    <Vec<JSXElementChild> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<JSXElementChild> as VisitMutWith<V>>::visit_mut_with(children, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Closing,
-                    ));
-                    <Option<JSXClosingElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        closing,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<JSXClosingElement> as VisitMutWith<V>>::visit_mut_with(closing, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXElementChild {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element_child`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_child(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXElementChild {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_element_child`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_element_child(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXElementChild::JSXText { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::Jsxtext,
-                ));
-                <JSXText as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXText as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXElementChild::JSXExprContainer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::JsxexprContainer,
-                ));
-                <JSXExprContainer as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXExprContainer as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXElementChild::JSXSpreadChild { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::JsxspreadChild,
-                ));
-                <JSXSpreadChild as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXSpreadChild as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXElementChild::JSXElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::Jsxelement,
-                ));
-                <Box<JSXElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXElement> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXElementChild::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::Jsxfragment,
-                ));
-                <JSXFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXFragment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXElementName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXElementName {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_element_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_element_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXElementName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
-                    self::fields::JSXElementNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXElementName::JSXMemberExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
-                    self::fields::JSXElementNameField::JsxmemberExpr,
-                ));
-                <JSXMemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXMemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXElementName::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
-                    self::fields::JSXElementNameField::JsxnamespacedName,
-                ));
-                <JSXNamespacedName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXNamespacedName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXEmptyExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_empty_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXEmptyExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_empty_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_empty_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXEmptyExpr { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXEmptyExpr(
-                        self::fields::JSXEmptyExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXExpr::JSXEmptyExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExpr(
-                    self::fields::JSXExprField::JsxemptyExpr,
-                ));
-                <JSXEmptyExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXEmptyExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::JSXExpr(self::fields::JSXExprField::Expr));
-                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXExprContainer {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_expr_container`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_expr_container(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXExprContainer {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_expr_container`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_expr_container(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXExprContainer { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
-                        self::fields::JSXExprContainerField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
-                        self::fields::JSXExprContainerField::Expr,
-                    ));
-                    <JSXExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXExpr as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXFragment {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_fragment`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXFragment {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_fragment`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_fragment(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXFragment {
                 span,
@@ -85002,181 +60607,89 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXFragment {
                 closing,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Opening,
-                    ));
-                    <JSXOpeningFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        opening,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXOpeningFragment as VisitMutWith<V>>::visit_mut_with(opening, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Children(usize::MAX),
-                    ));
-                    <Vec<JSXElementChild> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<JSXElementChild> as VisitMutWith<V>>::visit_mut_with(children, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Closing,
-                    ));
-                    <JSXClosingFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        closing,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXClosingFragment as VisitMutWith<V>>::visit_mut_with(closing, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXMemberExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_member_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_member_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXMemberExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_member_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_member_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXMemberExpr { span, obj, prop } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
-                        self::fields::JSXMemberExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
-                        self::fields::JSXMemberExprField::Obj,
-                    ));
-                    <JSXObject as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXObject as VisitMutWith<V>>::visit_mut_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
-                        self::fields::JSXMemberExprField::Prop,
-                    ));
-                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitMutWith<V>>::visit_mut_with(prop, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXNamespacedName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_namespaced_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXNamespacedName {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_namespaced_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_namespaced_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXNamespacedName { span, ns, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
-                        self::fields::JSXNamespacedNameField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
-                        self::fields::JSXNamespacedNameField::Ns,
-                    ));
-                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ns,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitMutWith<V>>::visit_mut_with(ns, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
-                        self::fields::JSXNamespacedNameField::Name,
-                    ));
-                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXObject {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_object`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_object(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXObject {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_object`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_object(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXObject::JSXMemberExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
-                    self::fields::JSXObjectField::JsxmemberExpr,
-                ));
-                <Box<JSXMemberExpr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<JSXMemberExpr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             JSXObject::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
-                    self::fields::JSXObjectField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXOpeningElement {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_opening_element`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_opening_element(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXOpeningElement {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_opening_element`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_opening_element(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXOpeningElement {
                 name,
@@ -85186,516 +60699,270 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXOpeningElement {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::Name,
-                    ));
-                    <JSXElementName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <JSXElementName as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::Attrs(usize::MAX),
-                    ));
-                    <Vec<JSXAttrOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        attrs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<JSXAttrOrSpread> as VisitMutWith<V>>::visit_mut_with(attrs, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXOpeningFragment {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_opening_fragment`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXOpeningFragment {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_opening_fragment`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_opening_fragment(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXOpeningFragment { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningFragment(
-                        self::fields::JSXOpeningFragmentField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXSpreadChild {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_spread_child`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_spread_child(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXSpreadChild {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_spread_child`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_spread_child(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXSpreadChild { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
-                        self::fields::JSXSpreadChildField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
-                        self::fields::JSXSpreadChildField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXText {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_text`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_text(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for JSXText {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_text`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_text(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             JSXText { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Raw));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Key {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_key`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_key(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Key {
+    #[doc = "Calls [VisitMut`::visit_mut_key`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_key(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Key::Private { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Private));
-                <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Key::Public { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Public));
-                <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyValuePatProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_key_value_pat_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyValuePatProp {
+    #[doc = "Calls [VisitMut`::visit_mut_key_value_pat_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_key_value_pat_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             KeyValuePatProp { key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
-                        self::fields::KeyValuePatPropField::Key,
-                    ));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
-                        self::fields::KeyValuePatPropField::Value,
-                    ));
-                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyValueProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_key_value_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_key_value_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for KeyValueProp {
+    #[doc = "Calls [VisitMut`::visit_mut_key_value_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_key_value_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             KeyValueProp { key, value } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
-                        self::fields::KeyValuePropField::Key,
-                    ));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
-                        self::fields::KeyValuePropField::Value,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LabeledStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_labeled_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_labeled_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for LabeledStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_labeled_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_labeled_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             LabeledStmt { span, label, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
-                        self::fields::LabeledStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
-                        self::fields::LabeledStmtField::Label,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(label, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
-                        self::fields::LabeledStmtField::Body,
-                    ));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Lit {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_lit`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_lit(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Lit {
+    #[doc = "Calls [VisitMut`::visit_mut_lit`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_lit(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Lit::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Str));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Lit::Bool { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Bool));
-                <Bool as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Bool as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Lit::Null { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Null));
-                <Null as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Null as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Lit::Num { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Num));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Lit::BigInt { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::BigInt));
-                <BigInt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BigInt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Lit::Regex { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Regex));
-                <Regex as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Regex as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Lit::JSXText { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Jsxtext));
-                <JSXText as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <JSXText as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MemberExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_member_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_member_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MemberExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_member_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_member_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MemberExpr { span, obj, prop } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
-                        self::fields::MemberExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
-                        self::fields::MemberExprField::Obj,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
-                        self::fields::MemberExprField::Prop,
-                    ));
-                    <MemberProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MemberProp as VisitMutWith<V>>::visit_mut_with(prop, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MemberProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_member_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_member_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MemberProp {
+    #[doc = "Calls [VisitMut`::visit_mut_member_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_member_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MemberProp::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
-                    self::fields::MemberPropField::Ident,
-                ));
-                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MemberProp::PrivateName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
-                    self::fields::MemberPropField::PrivateName,
-                ));
-                <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <PrivateName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             MemberProp::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
-                    self::fields::MemberPropField::Computed,
-                ));
-                <ComputedPropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComputedPropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MetaPropExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_meta_prop_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_meta_prop_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MetaPropExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_meta_prop_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_meta_prop_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MetaPropExpr { span, kind } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
-                        self::fields::MetaPropExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
-                        self::fields::MetaPropExprField::Kind,
-                    ));
-                    <MetaPropKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MetaPropKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MetaPropKind {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_meta_prop_kind`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_meta_prop_kind(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MetaPropKind {
+    #[doc = "Calls [VisitMut`::visit_mut_meta_prop_kind`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_meta_prop_kind(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MetaPropKind::NewTarget => {}
             MetaPropKind::ImportMeta => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MethodKind {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_method_kind`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_method_kind(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MethodKind {
+    #[doc = "Calls [VisitMut`::visit_mut_method_kind`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_method_kind(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MethodKind::Method => {}
             MethodKind::Getter => {}
@@ -85703,50 +60970,32 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MethodKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MethodProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_method_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_method_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for MethodProp {
+    #[doc = "Calls [VisitMut`::visit_mut_method_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_method_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             MethodProp { key, function } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
-                        self::fields::MethodPropField::Key,
-                    ));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
-                        self::fields::MethodPropField::Function,
-                    ));
-                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Module {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_module`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Module {
+    #[doc = "Calls [VisitMut`::visit_mut_module`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_module(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Module {
                 span,
@@ -85754,215 +61003,97 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Module {
                 shebang,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Module(
-                        self::fields::ModuleField::Body(usize::MAX),
-                    ));
-                    <Vec<ModuleItem> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ModuleItem> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Shebang));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        shebang,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(shebang, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ModuleDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ModuleDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_module_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_module_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ModuleDecl::Import { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::Import,
-                ));
-                <ImportDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ImportDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::ExportDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportDecl,
-                ));
-                <ExportDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::ExportNamed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportNamed,
-                ));
-                <NamedExport as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <NamedExport as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::ExportDefaultDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportDefaultDecl,
-                ));
-                <ExportDefaultDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDefaultDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::ExportDefaultExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportDefaultExpr,
-                ));
-                <ExportDefaultExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportDefaultExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::ExportAll { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportAll,
-                ));
-                <ExportAll as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExportAll as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::TsImportEquals { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::TsImportEquals,
-                ));
-                <Box<TsImportEqualsDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsImportEqualsDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::TsExportAssignment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::TsExportAssignment,
-                ));
-                <TsExportAssignment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsExportAssignment as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleDecl::TsNamespaceExport { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::TsNamespaceExport,
-                ));
-                <TsNamespaceExportDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNamespaceExportDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ModuleExportName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_export_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_export_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ModuleExportName {
+    #[doc = "Calls [VisitMut`::visit_mut_module_export_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_module_export_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ModuleExportName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
-                    self::fields::ModuleExportNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleExportName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
-                    self::fields::ModuleExportNameField::Str,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ModuleItem {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_item`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_item(visitor, self, __ast_path)
-    }
-
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        match self {
-            ModuleItem::ModuleDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
-                    self::fields::ModuleItemField::ModuleDecl,
-                ));
-                <ModuleDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ModuleItem {
+    #[doc = "Calls [VisitMut`::visit_mut_module_item`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_module_item(visitor, self)
+    }
+
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        match self {
+            ModuleItem::ModuleDecl { 0: _field_0 } => {
+                <ModuleDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ModuleItem::Stmt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
-                    self::fields::ModuleItemField::Stmt,
-                ));
-                <Stmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Stmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamedExport {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_named_export`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_named_export(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NamedExport {
+    #[doc = "Calls [VisitMut`::visit_mut_named_export`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_named_export(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NamedExport {
                 span,
@@ -85972,58 +61103,28 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamedExport {
                 with,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::Specifiers(usize::MAX),
-                    ));
-                    <Vec<ExportSpecifier> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        specifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ExportSpecifier> as VisitMutWith<V>>::visit_mut_with(specifiers, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::Src,
-                    ));
-                    <Option<Box<Str>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Str>> as VisitMutWith<V>>::visit_mut_with(src, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::With,
-                    ));
-                    <Option<Box<ObjectLit>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<ObjectLit>> as VisitMutWith<V>>::visit_mut_with(with, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NewExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_new_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_new_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for NewExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_new_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_new_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             NewExpr {
                 span,
@@ -86033,151 +61134,87 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NewExpr {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Callee));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(callee, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NewExpr(
-                        self::fields::NewExprField::Args(usize::MAX),
-                    ));
-                    <Option<Vec<ExprOrSpread>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Vec<ExprOrSpread>> as VisitMutWith<V>>::visit_mut_with(args, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::TypeArgs));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Null {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_null`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_null(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Null {
+    #[doc = "Calls [VisitMut`::visit_mut_null`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_null(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Null { span } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Null(self::fields::NullField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Number {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_number`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_number(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Number {
+    #[doc = "Calls [VisitMut`::visit_mut_number`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_number(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Number { span, value, raw } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ObjectLit {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_lit`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_lit(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ObjectLit {
+    #[doc = "Calls [VisitMut`::visit_mut_object_lit`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_object_lit(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ObjectLit { span, props } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ObjectLit(self::fields::ObjectLitField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectLit(
-                        self::fields::ObjectLitField::Props(usize::MAX),
-                    ));
-                    <Vec<PropOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        props,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<PropOrSpread> as VisitMutWith<V>>::visit_mut_with(props, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ObjectPat {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_pat`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_pat(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ObjectPat {
+    #[doc = "Calls [VisitMut`::visit_mut_object_pat`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_object_pat(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ObjectPat {
                 span,
@@ -86186,90 +61223,45 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ObjectPat {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ObjectPat(self::fields::ObjectPatField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
-                        self::fields::ObjectPatField::Props(usize::MAX),
-                    ));
-                    <Vec<ObjectPatProp> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        props,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ObjectPatProp> as VisitMutWith<V>>::visit_mut_with(props, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
-                        self::fields::ObjectPatField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ObjectPatProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_pat_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ObjectPatProp {
+    #[doc = "Calls [VisitMut`::visit_mut_object_pat_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_object_pat_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ObjectPatProp::KeyValue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
-                    self::fields::ObjectPatPropField::KeyValue,
-                ));
-                <KeyValuePatProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <KeyValuePatProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ObjectPatProp::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
-                    self::fields::ObjectPatPropField::Assign,
-                ));
-                <AssignPatProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignPatProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ObjectPatProp::Rest { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
-                    self::fields::ObjectPatPropField::Rest,
-                ));
-                <RestPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RestPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptCall {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_call`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_call(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptCall {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_call`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_call(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             OptCall {
                 span,
@@ -86279,93 +61271,50 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptCall {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Callee));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(callee, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptCall(
-                        self::fields::OptCallField::Args(usize::MAX),
-                    ));
-                    <Vec<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(args, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::TypeArgs));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptChainBase {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_chain_base`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_chain_base(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptChainBase {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_chain_base`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_chain_base(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             OptChainBase::Member { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
-                    self::fields::OptChainBaseField::Member,
-                ));
-                <MemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             OptChainBase::Call { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
-                    self::fields::OptChainBaseField::Call,
-                ));
-                <OptCall as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <OptCall as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptChainExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_chain_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_chain_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for OptChainExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_chain_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_chain_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             OptChainExpr {
                 span,
@@ -86373,38 +61322,22 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptChainExpr {
                 base,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
-                        self::fields::OptChainExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
-                        self::fields::OptChainExprField::Base,
-                    ));
-                    <Box<OptChainBase> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        base,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<OptChainBase> as VisitMutWith<V>>::visit_mut_with(base, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Param {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_param`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_param(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Param {
+    #[doc = "Calls [VisitMut`::visit_mut_param`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_param(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Param {
                 span,
@@ -86412,188 +61345,93 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Param {
                 pat,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Param(
-                        self::fields::ParamField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Pat));
-                    <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        pat,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Pat as VisitMutWith<V>>::visit_mut_with(pat, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ParamOrTsParamProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_param_or_ts_param_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ParamOrTsParamProp {
+    #[doc = "Calls [VisitMut`::visit_mut_param_or_ts_param_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_param_or_ts_param_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ParamOrTsParamProp::TsParamProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
-                    self::fields::ParamOrTsParamPropField::TsParamProp,
-                ));
-                <TsParamProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsParamProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             ParamOrTsParamProp::Param { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
-                    self::fields::ParamOrTsParamPropField::Param,
-                ));
-                <Param as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Param as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ParenExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_paren_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_paren_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ParenExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_paren_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_paren_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ParenExpr { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Expr));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Pat {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pat`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pat(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Pat {
+    #[doc = "Calls [VisitMut`::visit_mut_pat`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pat(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Pat::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Ident));
-                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Pat::Array { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Array));
-                <ArrayPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Pat::Rest { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Rest));
-                <RestPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RestPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Pat::Object { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Object));
-                <ObjectPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Pat::Assign { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Assign));
-                <AssignPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Pat::Invalid { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Invalid));
-                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Pat::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Expr));
-                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateMethod {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_private_method`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_method(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateMethod {
+    #[doc = "Calls [VisitMut`::visit_mut_private_method`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_private_method(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PrivateMethod {
                 span,
@@ -86607,103 +61445,53 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateMethod {
                 is_override,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Key,
-                    ));
-                    <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PrivateName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Function,
-                    ));
-                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Function> as VisitMutWith<V>>::visit_mut_with(function, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Kind,
-                    ));
-                    <MethodKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <MethodKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
                         accessibility,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_private_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateName {
+    #[doc = "Calls [VisitMut`::visit_mut_private_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_private_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PrivateName { span, name } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
-                        self::fields::PrivateNameField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
-                        self::fields::PrivateNameField::Name,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_private_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_private_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PrivateProp {
+    #[doc = "Calls [VisitMut`::visit_mut_private_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_private_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PrivateProp {
                 span,
@@ -86720,320 +61508,151 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateProp {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Key,
-                    ));
-                    <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PrivateName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Value,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
                         accessibility,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Program {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_program`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_program(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Program {
+    #[doc = "Calls [VisitMut`::visit_mut_program`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_program(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Program::Module { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Module));
-                <Module as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Module as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Program::Script { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Script));
-                <Script as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Script as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Prop {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Prop {
+    #[doc = "Calls [VisitMut`::visit_mut_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Prop::Shorthand { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Shorthand));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Prop::KeyValue { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::KeyValue));
-                <KeyValueProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <KeyValueProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Prop::Assign { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Assign));
-                <AssignProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Prop::Getter { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Getter));
-                <GetterProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <GetterProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Prop::Setter { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Setter));
-                <SetterProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SetterProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Prop::Method { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Method));
-                <MethodProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MethodProp as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PropName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PropName {
+    #[doc = "Calls [VisitMut`::visit_mut_prop_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_prop_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PropName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Ident));
-                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PropName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Str));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PropName::Num { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Num));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PropName::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropName(
-                    self::fields::PropNameField::Computed,
-                ));
-                <ComputedPropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComputedPropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PropName::BigInt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::BigInt));
-                <BigInt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BigInt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PropOrSpread {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop_or_spread`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for PropOrSpread {
+    #[doc = "Calls [VisitMut`::visit_mut_prop_or_spread`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_prop_or_spread(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             PropOrSpread::Spread { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
-                    self::fields::PropOrSpreadField::Spread,
-                ));
-                <SpreadElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SpreadElement as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             PropOrSpread::Prop { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
-                    self::fields::PropOrSpreadField::Prop,
-                ));
-                <Box<Prop> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Prop> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Regex {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_regex`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_regex(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Regex {
+    #[doc = "Calls [VisitMut`::visit_mut_regex`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_regex(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Regex { span, exp, flags } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Exp));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        exp,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(exp, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Regex(self::fields::RegexField::Flags));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        flags,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(flags, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for RestPat {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_rest_pat`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_rest_pat(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for RestPat {
+    #[doc = "Calls [VisitMut`::visit_mut_rest_pat`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_rest_pat(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             RestPat {
                 span,
@@ -87042,90 +61661,47 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for RestPat {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RestPat(
-                        self::fields::RestPatField::Dot3Token,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        dot3_token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(dot3_token, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Arg));
-                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::TypeAnn));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ReturnStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_return_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_return_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ReturnStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_return_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_return_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ReturnStmt { span, arg } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
-                        self::fields::ReturnStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
-                        self::fields::ReturnStmtField::Arg,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Script {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_script`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_script(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Script {
+    #[doc = "Calls [VisitMut`::visit_mut_script`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_script(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Script {
                 span,
@@ -87133,80 +61709,44 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Script {
                 shebang,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Script(
-                        self::fields::ScriptField::Body(usize::MAX),
-                    ));
-                    <Vec<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Shebang));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        shebang,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(shebang, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SeqExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_seq_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_seq_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SeqExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_seq_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_seq_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SeqExpr { span, exprs } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::SeqExpr(self::fields::SeqExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SeqExpr(
-                        self::fields::SeqExprField::Exprs(usize::MAX),
-                    ));
-                    <Vec<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        exprs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(exprs, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SetterProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_setter_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_setter_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SetterProp {
+    #[doc = "Calls [VisitMut`::visit_mut_setter_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_setter_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SetterProp {
                 span,
@@ -87216,634 +61756,280 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SetterProp {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Key,
-                    ));
-                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <PropName as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::ThisParam,
-                    ));
-                    <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        this_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Pat> as VisitMutWith<V>>::visit_mut_with(this_param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Param,
-                    ));
-                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Pat> as VisitMutWith<V>>::visit_mut_with(param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Body,
-                    ));
-                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SimpleAssignTarget {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_simple_assign_target`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_simple_assign_target(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SimpleAssignTarget {
+    #[doc = "Calls [VisitMut`::visit_mut_simple_assign_target`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_simple_assign_target(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SimpleAssignTarget::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Ident,
-                ));
-                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::Member { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Member,
-                ));
-                <MemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <MemberExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::SuperProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::SuperProp,
-                ));
-                <SuperPropExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SuperPropExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::Paren { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Paren,
-                ));
-                <ParenExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ParenExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::OptChain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::OptChain,
-                ));
-                <OptChainExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <OptChainExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsAs { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsAs,
-                ));
-                <TsAsExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsAsExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsSatisfies { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsSatisfies,
-                ));
-                <TsSatisfiesExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsSatisfiesExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsNonNull { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsNonNull,
-                ));
-                <TsNonNullExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNonNullExpr as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsTypeAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsTypeAssertion,
-                ));
-                <TsTypeAssertion as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeAssertion as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::TsInstantiation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsInstantiation,
-                ));
-                <TsInstantiation as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsInstantiation as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SimpleAssignTarget::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Invalid,
-                ));
-                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Invalid as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SpreadElement {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_spread_element`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_spread_element(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SpreadElement {
+    #[doc = "Calls [VisitMut`::visit_mut_spread_element`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_spread_element(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SpreadElement { dot3_token, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
-                        self::fields::SpreadElementField::Dot3Token,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        dot3_token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(dot3_token, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
-                        self::fields::SpreadElementField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for StaticBlock {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_static_block`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_static_block(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for StaticBlock {
+    #[doc = "Calls [VisitMut`::visit_mut_static_block`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_static_block(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             StaticBlock { span, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
-                        self::fields::StaticBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
-                        self::fields::StaticBlockField::Body,
-                    ));
-                    <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BlockStmt as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Stmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Stmt {
+    #[doc = "Calls [VisitMut`::visit_mut_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Stmt::Block { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Block));
-                <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BlockStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Empty { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Empty));
-                <EmptyStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <EmptyStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Debugger { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Debugger));
-                <DebuggerStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DebuggerStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::With { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::With));
-                <WithStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <WithStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Return { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Return));
-                <ReturnStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ReturnStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Labeled { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Labeled));
-                <LabeledStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <LabeledStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Break { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Break));
-                <BreakStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BreakStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Continue { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Continue));
-                <ContinueStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ContinueStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::If { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::If));
-                <IfStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IfStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Switch { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Switch));
-                <SwitchStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <SwitchStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Throw { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Throw));
-                <ThrowStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ThrowStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Try { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Try));
-                <Box<TryStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TryStmt> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::While { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::While));
-                <WhileStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <WhileStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::DoWhile { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::DoWhile));
-                <DoWhileStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <DoWhileStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::For { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::For));
-                <ForStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::ForIn { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForIn));
-                <ForInStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForInStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::ForOf { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForOf));
-                <ForOfStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ForOfStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Decl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Decl));
-                <Decl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Decl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             Stmt::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Expr));
-                <ExprStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ExprStmt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Str {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_str`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_str(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Str {
+    #[doc = "Calls [VisitMut`::visit_mut_str`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_str(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Str { span, value, raw } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(value, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Super {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_super`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_super(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Super {
+    #[doc = "Calls [VisitMut`::visit_mut_super`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_super(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Super { span } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Super(self::fields::SuperField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SuperProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_super_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_super_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SuperProp {
+    #[doc = "Calls [VisitMut`::visit_mut_super_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_super_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SuperProp::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
-                    self::fields::SuperPropField::Ident,
-                ));
-                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <IdentName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             SuperProp::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
-                    self::fields::SuperPropField::Computed,
-                ));
-                <ComputedPropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ComputedPropName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SuperPropExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_super_prop_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_super_prop_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SuperPropExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_super_prop_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_super_prop_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SuperPropExpr { span, obj, prop } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
-                        self::fields::SuperPropExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
-                        self::fields::SuperPropExprField::Obj,
-                    ));
-                    <Super as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Super as VisitMutWith<V>>::visit_mut_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
-                        self::fields::SuperPropExprField::Prop,
-                    ));
-                    <SuperProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <SuperProp as VisitMutWith<V>>::visit_mut_with(prop, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SwitchCase {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_switch_case`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_case(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SwitchCase {
+    #[doc = "Calls [VisitMut`::visit_mut_switch_case`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_switch_case(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SwitchCase { span, test, cons } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
-                        self::fields::SwitchCaseField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
-                        self::fields::SwitchCaseField::Test,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
-                        self::fields::SwitchCaseField::Cons(usize::MAX),
-                    ));
-                    <Vec<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Stmt> as VisitMutWith<V>>::visit_mut_with(cons, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SwitchStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_switch_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for SwitchStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_switch_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_switch_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             SwitchStmt {
                 span,
@@ -87851,48 +62037,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SwitchStmt {
                 cases,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
-                        self::fields::SwitchStmtField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
-                        self::fields::SwitchStmtField::Discriminant,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        discriminant,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(discriminant, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
-                        self::fields::SwitchStmtField::Cases(usize::MAX),
-                    ));
-                    <Vec<SwitchCase> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        cases,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<SwitchCase> as VisitMutWith<V>>::visit_mut_with(cases, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TaggedTpl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_tagged_tpl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tagged_tpl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TaggedTpl {
+    #[doc = "Calls [VisitMut`::visit_mut_tagged_tpl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_tagged_tpl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TaggedTpl {
                 span,
@@ -87902,117 +62065,69 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TaggedTpl {
                 tpl,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tag));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        tag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TaggedTpl(
-                        self::fields::TaggedTplField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(tag, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tpl));
-                    <Box<Tpl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        tpl,
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                {
+                    <Box<Tpl> as VisitMutWith<V>>::visit_mut_with(tpl, visitor)
+                };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ThisExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_this_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_this_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ThisExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_this_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_this_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ThisExpr { span } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ThisExpr(self::fields::ThisExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ThrowStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_throw_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_throw_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for ThrowStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_throw_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_throw_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             ThrowStmt { span, arg } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Arg));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Tpl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_tpl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Tpl {
+    #[doc = "Calls [VisitMut`::visit_mut_tpl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_tpl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Tpl {
                 span,
@@ -88020,47 +62135,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Tpl {
                 quasis,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Tpl(self::fields::TplField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
-                        self::fields::TplField::Exprs(usize::MAX),
-                    ));
-                    <Vec<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        exprs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(exprs, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
-                        self::fields::TplField::Quasis(usize::MAX),
-                    ));
-                    <Vec<TplElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        quasis,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TplElement> as VisitMutWith<V>>::visit_mut_with(quasis, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TplElement {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_tpl_element`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl_element(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TplElement {
+    #[doc = "Calls [VisitMut`::visit_mut_tpl_element`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_tpl_element(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TplElement {
                 span,
@@ -88069,48 +62162,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TplElement {
                 raw,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
-                        self::fields::TplElementField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
-                        self::fields::TplElementField::Cooked,
-                    ));
-                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        cooked,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<swc_atoms::Atom> as VisitMutWith<V>>::visit_mut_with(cooked, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
-                        self::fields::TplElementField::Raw,
-                    ));
-                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(raw, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TruePlusMinus {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_true_plus_minus`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_true_plus_minus(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TruePlusMinus {
+    #[doc = "Calls [VisitMut`::visit_mut_true_plus_minus`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_true_plus_minus(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TruePlusMinus::True => {}
             TruePlusMinus::Plus => {}
@@ -88118,15 +62188,13 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TruePlusMinus {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TryStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_try_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_try_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TryStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_try_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_try_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TryStmt {
                 span,
@@ -88135,90 +62203,47 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TryStmt {
                 finalizer,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Block));
-                    <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <BlockStmt as VisitMutWith<V>>::visit_mut_with(block, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Handler));
-                    <Option<CatchClause> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        handler,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<CatchClause> as VisitMutWith<V>>::visit_mut_with(handler, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TryStmt(
-                        self::fields::TryStmtField::Finalizer,
-                    ));
-                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        finalizer,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<BlockStmt> as VisitMutWith<V>>::visit_mut_with(finalizer, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsArrayType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_array_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_array_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsArrayType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_array_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_array_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsArrayType { span, elem_type } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
-                        self::fields::TsArrayTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
-                        self::fields::TsArrayTypeField::ElemType,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        elem_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(elem_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsAsExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_as_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_as_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsAsExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_as_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_as_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsAsExpr {
                 span,
@@ -88226,46 +62251,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsAsExpr {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Expr));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsAsExpr(
-                        self::fields::TsAsExprField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsCallSignatureDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_call_signature_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsCallSignatureDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_call_signature_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_call_signature_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsCallSignatureDecl {
                 span,
@@ -88274,54 +62278,31 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsCallSignatureDecl
                 type_params,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
+                        visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConditionalType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_conditional_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_conditional_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConditionalType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_conditional_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_conditional_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsConditionalType {
                 span,
@@ -88331,103 +62312,50 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConditionalType {
                 false_type,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::CheckType,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        check_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::ExtendsType,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        extends_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::TrueType,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        true_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(check_type, visitor)
                 };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::FalseType,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        false_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                {
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(extends_type, visitor)
+                };
+                {
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(true_type, visitor)
+                };
+                {
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(false_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstAssertion {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_const_assertion`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_const_assertion(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstAssertion {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_const_assertion`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_const_assertion(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsConstAssertion { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
-                        self::fields::TsConstAssertionField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
-                        self::fields::TsConstAssertionField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstructSignatureDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_construct_signature_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstructSignatureDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_construct_signature_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_construct_signature_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsConstructSignatureDecl {
                 span,
@@ -88436,58 +62364,31 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstructSignatur
                 type_params,
             } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::Params(usize::MAX),
-                        ));
-                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::TypeAnn,
-                        ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::TypeParams,
-                        ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
+                        visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstructorType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_constructor_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_constructor_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsConstructorType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_constructor_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_constructor_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsConstructorType {
                 span,
@@ -88497,87 +62398,48 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstructorType {
                 is_abstract,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::TypeAnn,
-                    ));
-                    <Box<TsTypeAnn> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                {
+                    <Box<TsTypeAnn> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEntityName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_entity_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_entity_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEntityName {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_entity_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_entity_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsEntityName::TsQualifiedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
-                    self::fields::TsEntityNameField::TsQualifiedName,
-                ));
-                <Box<TsQualifiedName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<TsQualifiedName> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsEntityName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
-                    self::fields::TsEntityNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEnumDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEnumDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_enum_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsEnumDecl {
                 span,
@@ -88587,160 +62449,83 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEnumDecl {
                 members,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
-                        self::fields::TsEnumDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsEnumDecl(self::fields::TsEnumDeclField::Id));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
-                        self::fields::TsEnumDeclField::Members(usize::MAX),
-                    ));
-                    <Vec<TsEnumMember> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        members,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsEnumMember> as VisitMutWith<V>>::visit_mut_with(members, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEnumMember {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_member`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_member(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEnumMember {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_member`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_enum_member(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsEnumMember { span, id, init } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
-                        self::fields::TsEnumMemberField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
-                        self::fields::TsEnumMemberField::Id,
-                    ));
-                    <TsEnumMemberId as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsEnumMemberId as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
-                        self::fields::TsEnumMemberField::Init,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(init, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEnumMemberId {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_member_id`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsEnumMemberId {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_member_id`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_enum_member_id(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsEnumMemberId::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
-                    self::fields::TsEnumMemberIdField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsEnumMemberId::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
-                    self::fields::TsEnumMemberIdField::Str,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsExportAssignment {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_export_assignment`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_export_assignment(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsExportAssignment {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_export_assignment`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_export_assignment(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsExportAssignment { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
-                        self::fields::TsExportAssignmentField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
-                        self::fields::TsExportAssignmentField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsExprWithTypeArgs {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_expr_with_type_args`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsExprWithTypeArgs {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_expr_with_type_args`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_expr_with_type_args(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsExprWithTypeArgs {
                 span,
@@ -88748,164 +62533,86 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsExprWithTypeArgs
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
-                        self::fields::TsExprWithTypeArgsField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
-                        self::fields::TsExprWithTypeArgsField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
-                        self::fields::TsExprWithTypeArgsField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsExternalModuleRef {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_external_module_ref`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsExternalModuleRef {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_external_module_ref`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_external_module_ref(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsExternalModuleRef { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
-                        self::fields::TsExternalModuleRefField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
-                        self::fields::TsExternalModuleRefField::Expr,
-                    ));
-                    <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Str as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsFnOrConstructorType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_or_constructor_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsFnOrConstructorType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_or_constructor_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_fn_or_constructor_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsFnOrConstructorType::TsFnType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
-                    self::fields::TsFnOrConstructorTypeField::TsFnType,
-                ));
-                <TsFnType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsFnType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsFnOrConstructorType::TsConstructorType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
-                    self::fields::TsFnOrConstructorTypeField::TsConstructorType,
-                ));
-                <TsConstructorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConstructorType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsFnParam {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_param`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_param(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsFnParam {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_param`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_fn_param(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsFnParam::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
-                    self::fields::TsFnParamField::Ident,
-                ));
-                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsFnParam::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
-                    self::fields::TsFnParamField::Array,
-                ));
-                <ArrayPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ArrayPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsFnParam::Rest { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsFnParam(self::fields::TsFnParamField::Rest));
-                <RestPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <RestPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsFnParam::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
-                    self::fields::TsFnParamField::Object,
-                ));
-                <ObjectPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <ObjectPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsFnType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsFnType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_fn_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsFnType {
                 span,
@@ -88914,53 +62621,31 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsFnType {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsFnType(self::fields::TsFnTypeField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
-                        self::fields::TsFnTypeField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
-                        self::fields::TsFnTypeField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
-                        self::fields::TsFnTypeField::TypeAnn,
-                    ));
-                    <Box<TsTypeAnn> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                {
+                    <Box<TsTypeAnn> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsGetterSignature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_getter_signature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_getter_signature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsGetterSignature {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_getter_signature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_getter_signature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsGetterSignature {
                 span,
@@ -88969,48 +62654,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsGetterSignature {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
-                        self::fields::TsGetterSignatureField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
-                        self::fields::TsGetterSignatureField::Key,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
-                        self::fields::TsGetterSignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsImportEqualsDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_import_equals_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsImportEqualsDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_import_equals_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_import_equals_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsImportEqualsDecl {
                 span,
@@ -89020,48 +62682,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsImportEqualsDecl
                 module_ref,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
-                        self::fields::TsImportEqualsDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
-                        self::fields::TsImportEqualsDeclField::Id,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
-                        self::fields::TsImportEqualsDeclField::ModuleRef,
-                    ));
-                    <TsModuleRef as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        module_ref,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsModuleRef as VisitMutWith<V>>::visit_mut_with(module_ref, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsImportType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_import_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_import_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsImportType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_import_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_import_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsImportType {
                 span,
@@ -89070,54 +62709,30 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsImportType {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::Arg,
-                    ));
-                    <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Str as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::Qualifier,
-                    ));
-                    <Option<TsEntityName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        qualifier,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TsEntityName> as VisitMutWith<V>>::visit_mut_with(qualifier, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIndexSignature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_index_signature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_index_signature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIndexSignature {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_index_signature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_index_signature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsIndexSignature {
                 params,
@@ -89127,48 +62742,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIndexSignature {
                 span,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
-                        self::fields::TsIndexSignatureField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
-                        self::fields::TsIndexSignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
-                        self::fields::TsIndexSignatureField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIndexedAccessType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_indexed_access_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIndexedAccessType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_indexed_access_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_indexed_access_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsIndexedAccessType {
                 span,
@@ -89177,83 +62769,44 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIndexedAccessType
                 index_type,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
-                        self::fields::TsIndexedAccessTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
-                        self::fields::TsIndexedAccessTypeField::ObjType,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        obj_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(obj_type, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
-                        self::fields::TsIndexedAccessTypeField::IndexType,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        index_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(index_type, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInferType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_infer_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_infer_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInferType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_infer_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_infer_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsInferType { span, type_param } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
-                        self::fields::TsInferTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
-                        self::fields::TsInferTypeField::TypeParam,
-                    ));
-                    <TsTypeParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeParam as VisitMutWith<V>>::visit_mut_with(type_param, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInstantiation {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_instantiation`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_instantiation(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInstantiation {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_instantiation`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_instantiation(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsInstantiation {
                 span,
@@ -89261,79 +62814,46 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInstantiation {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
-                        self::fields::TsInstantiationField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
-                        self::fields::TsInstantiationField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
-                        self::fields::TsInstantiationField::TypeArgs,
-                    ));
-                    < Box < TsTypeParamInstantiation > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Box<TsTypeParamInstantiation> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInterfaceBody {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_interface_body`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_interface_body(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInterfaceBody {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_interface_body`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_interface_body(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsInterfaceBody { span, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
-                        self::fields::TsInterfaceBodyField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
-                        self::fields::TsInterfaceBodyField::Body(usize::MAX),
-                    ));
-                    <Vec<TsTypeElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTypeElement> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInterfaceDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_interface_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_interface_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsInterfaceDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_interface_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_interface_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsInterfaceDecl {
                 span,
@@ -89344,134 +62864,72 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInterfaceDecl {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Id,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Extends(usize::MAX),
-                    ));
-                    <Vec<TsExprWithTypeArgs> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        extends,
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Body,
-                    ));
-                    <TsInterfaceBody as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsExprWithTypeArgs> as VisitMutWith<V>>::visit_mut_with(extends, visitor)
+                };
+                {
+                    <TsInterfaceBody as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIntersectionType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_intersection_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_intersection_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsIntersectionType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_intersection_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_intersection_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsIntersectionType { span, types } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
-                        self::fields::TsIntersectionTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
-                        self::fields::TsIntersectionTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(types, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsKeywordType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_keyword_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_keyword_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsKeywordType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_keyword_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_keyword_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsKeywordType { span, kind } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
-                        self::fields::TsKeywordTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
-                        self::fields::TsKeywordTypeField::Kind,
-                    ));
-                    <TsKeywordTypeKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsKeywordTypeKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsKeywordTypeKind {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_keyword_type_kind`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsKeywordTypeKind {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_keyword_type_kind`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_keyword_type_kind(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsKeywordTypeKind::TsAnyKeyword => {}
             TsKeywordTypeKind::TsUnknownKeyword => {}
@@ -89489,188 +62947,96 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsKeywordTypeKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsLit {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_lit`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_lit(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsLit {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_lit`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_lit(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsLit::Number { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Number));
-                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Number as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsLit::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Str));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsLit::Bool { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Bool));
-                <Bool as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Bool as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsLit::BigInt { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::BigInt));
-                <BigInt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BigInt as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsLit::Tpl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Tpl));
-                <TsTplLitType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTplLitType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsLitType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_lit_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_lit_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsLitType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_lit_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_lit_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsLitType { span, lit } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Lit));
-                    <TsLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        lit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsLit as VisitMutWith<V>>::visit_mut_with(lit, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsMappedType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_mapped_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_mapped_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsMappedType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_mapped_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_mapped_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsMappedType {
                 span,
                 readonly,
                 type_param,
                 name_type,
-                optional,
-                type_ann,
-            } => {
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                optional,
+                type_ann,
+            } => {
+                {
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::Readonly,
-                    ));
-                    <Option<TruePlusMinus> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        readonly,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TruePlusMinus> as VisitMutWith<V>>::visit_mut_with(readonly, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::TypeParam,
-                    ));
-                    <TsTypeParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeParam as VisitMutWith<V>>::visit_mut_with(type_param, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::NameType,
-                    ));
-                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(name_type, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::Optional,
-                    ));
-                    <Option<TruePlusMinus> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        optional,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TruePlusMinus> as VisitMutWith<V>>::visit_mut_with(optional, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::TypeAnn,
-                    ));
-                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsMethodSignature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_method_signature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_method_signature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsMethodSignature {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_method_signature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_method_signature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsMethodSignature {
                 span,
@@ -89682,99 +63048,53 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsMethodSignature {
                 type_params,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::Key,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsFnParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
+                        visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleBlock {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_block`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_block(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleBlock {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_module_block`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_module_block(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsModuleBlock { span, body } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
-                        self::fields::TsModuleBlockField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
-                        self::fields::TsModuleBlockField::Body(usize::MAX),
-                    ));
-                    <Vec<ModuleItem> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<ModuleItem> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_module_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_module_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsModuleDecl {
                 span,
@@ -89784,147 +63104,76 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleDecl {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
-                        self::fields::TsModuleDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
-                        self::fields::TsModuleDeclField::Id,
-                    ));
-                    <TsModuleName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsModuleName as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
-                        self::fields::TsModuleDeclField::Body,
-                    ));
-                    <Option<TsNamespaceBody> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<TsNamespaceBody> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleName {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_module_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_module_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsModuleName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
-                    self::fields::TsModuleNameField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsModuleName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
-                    self::fields::TsModuleNameField::Str,
-                ));
-                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Str as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleRef {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_ref`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_module_ref(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsModuleRef {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_module_ref`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_module_ref(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsModuleRef::TsEntityName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
-                    self::fields::TsModuleRefField::TsEntityName,
-                ));
-                <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsEntityName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsModuleRef::TsExternalModuleRef { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
-                    self::fields::TsModuleRefField::TsExternalModuleRef,
-                ));
-                <TsExternalModuleRef as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsExternalModuleRef as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNamespaceBody {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_namespace_body`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_body(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNamespaceBody {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_namespace_body`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_namespace_body(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsNamespaceBody::TsModuleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
-                    self::fields::TsNamespaceBodyField::TsModuleBlock,
-                ));
-                <TsModuleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsModuleBlock as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsNamespaceBody::TsNamespaceDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
-                    self::fields::TsNamespaceBodyField::TsNamespaceDecl,
-                ));
-                <TsNamespaceDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsNamespaceDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNamespaceDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_namespace_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNamespaceDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_namespace_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_namespace_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsNamespaceDecl {
                 span,
@@ -89934,155 +63183,82 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNamespaceDecl {
                 body,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
-                        self::fields::TsNamespaceDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
-                        self::fields::TsNamespaceDeclField::Id,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
-                        self::fields::TsNamespaceDeclField::Body,
-                    ));
-                    <Box<TsNamespaceBody> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsNamespaceBody> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNamespaceExportDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_namespace_export_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNamespaceExportDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_namespace_export_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_namespace_export_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsNamespaceExportDecl { span, id } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
-                            self::fields::TsNamespaceExportDeclField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
-                            self::fields::TsNamespaceExportDeclField::Id,
-                        ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNonNullExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_non_null_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsNonNullExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_non_null_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_non_null_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsNonNullExpr { span, expr } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
-                        self::fields::TsNonNullExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
-                        self::fields::TsNonNullExprField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsOptionalType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_optional_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_optional_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsOptionalType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_optional_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_optional_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsOptionalType { span, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
-                        self::fields::TsOptionalTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
-                        self::fields::TsOptionalTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsParamProp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_param_prop`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_param_prop(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsParamProp {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_param_prop`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_param_prop(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsParamProp {
                 span,
@@ -90093,126 +63269,67 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsParamProp {
                 param,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Decorator> as VisitMutWith<V>>::visit_mut_with(decorators, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    <Option<Accessibility> as VisitMutWith<V>>::visit_mut_with(
                         accessibility,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Param,
-                    ));
-                    <TsParamPropParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsParamPropParam as VisitMutWith<V>>::visit_mut_with(param, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsParamPropParam {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_param_prop_param`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsParamPropParam {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_param_prop_param`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_param_prop_param(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsParamPropParam::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
-                    self::fields::TsParamPropParamField::Ident,
-                ));
-                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <BindingIdent as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsParamPropParam::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
-                    self::fields::TsParamPropParamField::Assign,
-                ));
-                <AssignPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <AssignPat as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsParenthesizedType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_parenthesized_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsParenthesizedType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_parenthesized_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_parenthesized_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsParenthesizedType { span, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
-                        self::fields::TsParenthesizedTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
-                        self::fields::TsParenthesizedTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsPropertySignature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_property_signature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_property_signature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsPropertySignature {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_property_signature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_property_signature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsPropertySignature {
                 span,
@@ -90223,128 +63340,66 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsPropertySignature
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
-                        self::fields::TsPropertySignatureField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
-                        self::fields::TsPropertySignatureField::Key,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
-                        self::fields::TsPropertySignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsQualifiedName {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_qualified_name`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_qualified_name(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsQualifiedName {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_qualified_name`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_qualified_name(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsQualifiedName { span, left, right } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
-                        self::fields::TsQualifiedNameField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
-                        self::fields::TsQualifiedNameField::Left,
-                    ));
-                    <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsEntityName as VisitMutWith<V>>::visit_mut_with(left, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
-                        self::fields::TsQualifiedNameField::Right,
-                    ));
-                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <IdentName as VisitMutWith<V>>::visit_mut_with(right, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsRestType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_rest_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_rest_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsRestType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_rest_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_rest_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsRestType { span, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
-                        self::fields::TsRestTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
-                        self::fields::TsRestTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsSatisfiesExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_satisfies_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsSatisfiesExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_satisfies_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_satisfies_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsSatisfiesExpr {
                 span,
@@ -90352,48 +63407,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsSatisfiesExpr {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
-                        self::fields::TsSatisfiesExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
-                        self::fields::TsSatisfiesExprField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
-                        self::fields::TsSatisfiesExprField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsSetterSignature {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_setter_signature`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_setter_signature(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsSetterSignature {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_setter_signature`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_setter_signature(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsSetterSignature {
                 span,
@@ -90402,106 +63434,58 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsSetterSignature {
                 param,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
-                        self::fields::TsSetterSignatureField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
-                        self::fields::TsSetterSignatureField::Key,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(key, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
-                        self::fields::TsSetterSignatureField::Param,
-                    ));
-                    <TsFnParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsFnParam as VisitMutWith<V>>::visit_mut_with(param, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsThisType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_this_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_this_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsThisType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_this_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_this_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsThisType { span } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisType(
-                        self::fields::TsThisTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsThisTypeOrIdent {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_this_type_or_ident`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsThisTypeOrIdent {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_this_type_or_ident`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_this_type_or_ident(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsThisTypeOrIdent::TsThisType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
-                    self::fields::TsThisTypeOrIdentField::TsThisType,
-                ));
-                <TsThisType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsThisType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsThisTypeOrIdent::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
-                    self::fields::TsThisTypeOrIdentField::Ident,
-                ));
-                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Ident as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTplLitType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tpl_lit_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTplLitType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_tpl_lit_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_tpl_lit_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTplLitType {
                 span,
@@ -90509,336 +63493,137 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTplLitType {
                 quasis,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
-                        self::fields::TsTplLitTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
-                        self::fields::TsTplLitTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(types, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
-                        self::fields::TsTplLitTypeField::Quasis(usize::MAX),
-                    ));
-                    <Vec<TplElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        quasis,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TplElement> as VisitMutWith<V>>::visit_mut_with(quasis, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTupleElement {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tuple_element`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_element(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTupleElement {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_tuple_element`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_tuple_element(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTupleElement { span, label, ty } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
-                        self::fields::TsTupleElementField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
-                        self::fields::TsTupleElementField::Label,
-                    ));
-                    <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Pat> as VisitMutWith<V>>::visit_mut_with(label, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
-                        self::fields::TsTupleElementField::Ty,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ty,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(ty, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTupleType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tuple_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTupleType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_tuple_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_tuple_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTupleType { span, elem_types } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
-                        self::fields::TsTupleTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
-                        self::fields::TsTupleTypeField::ElemTypes(usize::MAX),
-                    ));
-                    <Vec<TsTupleElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        elem_types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTupleElement> as VisitMutWith<V>>::visit_mut_with(elem_types, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsType::TsKeywordType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsKeywordType,
-                ));
-                <TsKeywordType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsKeywordType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsThisType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsThisType));
-                <TsThisType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsThisType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsFnOrConstructorType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsFnOrConstructorType,
-                ));
-                <TsFnOrConstructorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsFnOrConstructorType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsTypeRef { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeRef));
-                <TsTypeRef as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeRef as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsTypeQuery { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTypeQuery,
-                ));
-                <TsTypeQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeQuery as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsTypeLit { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeLit));
-                <TsTypeLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeLit as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsArrayType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsArrayType,
-                ));
-                <TsArrayType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsArrayType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsTupleType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTupleType,
-                ));
-                <TsTupleType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTupleType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsOptionalType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsOptionalType,
-                ));
-                <TsOptionalType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsOptionalType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsRestType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsRestType));
-                <TsRestType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsRestType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsUnionOrIntersectionType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsUnionOrIntersectionType,
-                ));
-                <TsUnionOrIntersectionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsUnionOrIntersectionType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsConditionalType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsConditionalType,
-                ));
-                <TsConditionalType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConditionalType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsInferType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsInferType,
-                ));
-                <TsInferType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsInferType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsParenthesizedType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsParenthesizedType,
-                ));
-                <TsParenthesizedType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsParenthesizedType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsTypeOperator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTypeOperator,
-                ));
-                <TsTypeOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypeOperator as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsIndexedAccessType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsIndexedAccessType,
-                ));
-                <TsIndexedAccessType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIndexedAccessType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsMappedType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsMappedType,
-                ));
-                <TsMappedType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsMappedType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsLitType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsLitType));
-                <TsLitType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsLitType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsTypePredicate { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTypePredicate,
-                ));
-                <TsTypePredicate as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsTypePredicate as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsType::TsImportType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsImportType,
-                ));
-                <TsImportType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsImportType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAliasDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_alias_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAliasDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_alias_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_alias_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeAliasDecl {
                 span,
@@ -90848,88 +63633,50 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAliasDecl {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::Id,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Ident as VisitMutWith<V>>::visit_mut_with(id, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
+                    <Option<Box<TsTypeParamDecl>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                {
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
+                };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAnn {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_ann`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_ann(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAnn {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_ann`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_ann(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeAnn { span, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsTypeAnn(self::fields::TsTypeAnnField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAnn(
-                        self::fields::TsTypeAnnField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAssertion {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_assertion`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_assertion(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeAssertion {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_assertion`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_assertion(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeAssertion {
                 span,
@@ -90937,210 +63684,98 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAssertion {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
-                        self::fields::TsTypeAssertionField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
-                        self::fields::TsTypeAssertionField::Expr,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(expr, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
-                        self::fields::TsTypeAssertionField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeElement {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_element`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_element(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeElement {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_element`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_element(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeElement::TsCallSignatureDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsCallSignatureDecl,
-                ));
-                <TsCallSignatureDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsCallSignatureDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsTypeElement::TsConstructSignatureDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsConstructSignatureDecl,
-                ));
-                <TsConstructSignatureDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsConstructSignatureDecl as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsTypeElement::TsPropertySignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsPropertySignature,
-                ));
-                <TsPropertySignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsPropertySignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsTypeElement::TsGetterSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsGetterSignature,
-                ));
-                <TsGetterSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsGetterSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsTypeElement::TsSetterSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsSetterSignature,
-                ));
-                <TsSetterSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsSetterSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsTypeElement::TsMethodSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsMethodSignature,
-                ));
-                <TsMethodSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsMethodSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsTypeElement::TsIndexSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsIndexSignature,
-                ));
-                <TsIndexSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIndexSignature as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeLit {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_lit`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_lit(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeLit {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_lit`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_lit(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeLit { span, members } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsTypeLit(self::fields::TsTypeLitField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeLit(
-                        self::fields::TsTypeLitField::Members(usize::MAX),
-                    ));
-                    <Vec<TsTypeElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        members,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTypeElement> as VisitMutWith<V>>::visit_mut_with(members, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeOperator {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_operator`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_operator(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeOperator {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_operator`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_operator(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeOperator { span, op, type_ann } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
-                        self::fields::TsTypeOperatorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
-                        self::fields::TsTypeOperatorField::Op,
-                    ));
-                    <TsTypeOperatorOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeOperatorOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
-                        self::fields::TsTypeOperatorField::TypeAnn,
-                    ));
-                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsType> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeOperatorOp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_operator_op`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeOperatorOp {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_operator_op`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_operator_op(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeOperatorOp::KeyOf => {}
             TsTypeOperatorOp::Unique => {}
@@ -91148,15 +63783,13 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeOperatorOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeParam {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_param`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeParam {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_param`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_param(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeParam {
                 span,
@@ -91168,130 +63801,66 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeParam {
                 default,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Name,
-                    ));
-                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Ident as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Constraint,
-                    ));
-                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        constraint,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(constraint, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Default,
-                    ));
-                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        default,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(default, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeParamDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_param_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeParamDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_param_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_param_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeParamDecl { span, params } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
-                        self::fields::TsTypeParamDeclField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
-                        self::fields::TsTypeParamDeclField::Params(usize::MAX),
-                    ));
-                    <Vec<TsTypeParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<TsTypeParam> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeParamInstantiation {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_param_instantiation`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeParamInstantiation {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_param_instantiation`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_param_instantiation(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeParamInstantiation { span, params } => {
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
-                            self::fields::TsTypeParamInstantiationField::Span,
-                        ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
-                            self::fields::TsTypeParamInstantiationField::Params(usize::MAX),
-                        ));
-                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(params, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypePredicate {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_predicate`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_predicate(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypePredicate {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_predicate`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_predicate(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypePredicate {
                 span,
@@ -91300,48 +63869,25 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypePredicate {
                 type_ann,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
-                        self::fields::TsTypePredicateField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
-                        self::fields::TsTypePredicateField::ParamName,
-                    ));
-                    <TsThisTypeOrIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        param_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsThisTypeOrIdent as VisitMutWith<V>>::visit_mut_with(param_name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
-                        self::fields::TsTypePredicateField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeAnn>> as VisitMutWith<V>>::visit_mut_with(type_ann, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeQuery {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_query`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_query(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeQuery {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_query`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_query(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeQuery {
                 span,
@@ -91349,77 +63895,44 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeQuery {
                 type_args,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
-                        self::fields::TsTypeQueryField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
-                        self::fields::TsTypeQueryField::ExprName,
-                    ));
-                    <TsTypeQueryExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        expr_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsTypeQueryExpr as VisitMutWith<V>>::visit_mut_with(expr_name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
-                        self::fields::TsTypeQueryField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_args, visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeQueryExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_query_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeQueryExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_query_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_query_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeQueryExpr::TsEntityName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
-                    self::fields::TsTypeQueryExprField::TsEntityName,
-                ));
-                <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsEntityName as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsTypeQueryExpr::Import { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
-                    self::fields::TsTypeQueryExprField::Import,
-                ));
-                <TsImportType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsImportType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeRef {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_ref`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_ref(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsTypeRef {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_ref`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_ref(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsTypeRef {
                 span,
@@ -91427,155 +63940,86 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeRef {
                 type_params,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsTypeRef(self::fields::TsTypeRefField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
-                        self::fields::TsTypeRefField::TypeName,
-                    ));
-                    <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        type_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <TsEntityName as VisitMutWith<V>>::visit_mut_with(type_name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
-                        self::fields::TsTypeRefField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as VisitMutWith<V>>::visit_mut_with(
+                        type_params,
+                        visitor,
+                    )
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsUnionOrIntersectionType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_union_or_intersection_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsUnionOrIntersectionType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_union_or_intersection_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_union_or_intersection_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsUnionOrIntersectionType::TsUnionType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
-                        self::fields::TsUnionOrIntersectionTypeField::TsUnionType,
-                    ));
-                <TsUnionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsUnionType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
-                        self::fields::TsUnionOrIntersectionTypeField::TsIntersectionType,
-                    ));
-                <TsIntersectionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <TsIntersectionType as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsUnionType {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_union_type`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_union_type(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for TsUnionType {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_union_type`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_union_type(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             TsUnionType { span, types } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
-                        self::fields::TsUnionTypeField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
-                        self::fields::TsUnionTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<Box<TsType>> as VisitMutWith<V>>::visit_mut_with(types, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnaryExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_unary_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unary_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnaryExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_unary_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_unary_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UnaryExpr { span, op, arg } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Op));
-                    <UnaryOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <UnaryOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Arg));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnaryOp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_unary_op`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_unary_op(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UnaryOp {
+    #[doc = "Calls [VisitMut`::visit_mut_unary_op`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_unary_op(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UnaryOp::Minus => {}
             UnaryOp::Plus => {}
@@ -91587,15 +64031,13 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnaryOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UpdateExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_update_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_update_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UpdateExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_update_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_update_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UpdateExpr {
                 span,
@@ -91604,62 +64046,38 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UpdateExpr {
                 arg,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
-                        self::fields::UpdateExprField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UpdateExpr(self::fields::UpdateExprField::Op));
-                    <UpdateOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <UpdateOp as VisitMutWith<V>>::visit_mut_with(op, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
-                        self::fields::UpdateExprField::Arg,
-                    ));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UpdateOp {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_update_op`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_update_op(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UpdateOp {
+    #[doc = "Calls [VisitMut`::visit_mut_update_op`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_update_op(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UpdateOp::PlusPlus => {}
             UpdateOp::MinusMinus => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UsingDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_using_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_using_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for UsingDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_using_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_using_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             UsingDecl {
                 span,
@@ -91667,37 +64085,22 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UsingDecl {
                 decls,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UsingDecl(self::fields::UsingDeclField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UsingDecl(
-                        self::fields::UsingDeclField::Decls(usize::MAX),
-                    ));
-                    <Vec<VarDeclarator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decls,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<VarDeclarator> as VisitMutWith<V>>::visit_mut_with(decls, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDecl {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_decl`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_decl(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDecl {
+    #[doc = "Calls [VisitMut`::visit_mut_var_decl`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_var_decl(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             VarDecl {
                 span,
@@ -91707,55 +64110,28 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDecl {
                 decls,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Ctxt));
-                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::SyntaxContext as VisitMutWith<V>>::visit_mut_with(ctxt, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Kind));
-                    <VarDeclKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <VarDeclKind as VisitMutWith<V>>::visit_mut_with(kind, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDecl(
-                        self::fields::VarDeclField::Decls(usize::MAX),
-                    ));
-                    <Vec<VarDeclarator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        decls,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Vec<VarDeclarator> as VisitMutWith<V>>::visit_mut_with(decls, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclKind {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_decl_kind`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_decl_kind(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclKind {
+    #[doc = "Calls [VisitMut`::visit_mut_var_decl_kind`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_var_decl_kind(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             VarDeclKind::Var => {}
             VarDeclKind::Let => {}
@@ -91763,48 +64139,30 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclOrExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_decl_or_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclOrExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_var_decl_or_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_var_decl_or_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             VarDeclOrExpr::VarDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
-                    self::fields::VarDeclOrExprField::VarDecl,
-                ));
-                <Box<VarDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<VarDecl> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
             VarDeclOrExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
-                    self::fields::VarDeclOrExprField::Expr,
-                ));
-                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                <Box<Expr> as VisitMutWith<V>>::visit_mut_with(_field_0, visitor);
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclarator {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_declarator`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_declarator(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for VarDeclarator {
+    #[doc = "Calls [VisitMut`::visit_mut_var_declarator`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_var_declarator(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             VarDeclarator {
                 span,
@@ -91813,132 +64171,69 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclarator {
                 definite,
             } => {
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
-                        self::fields::VarDeclaratorField::Span,
-                    ));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
-                        self::fields::VarDeclaratorField::Name,
-                    ));
-                    <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Pat as VisitMutWith<V>>::visit_mut_with(name, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
-                        self::fields::VarDeclaratorField::Init,
-                    ));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(init, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WhileStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_while_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_while_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for WhileStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_while_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_while_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             WhileStmt { span, test, body } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Test));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(test, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Body));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WithStmt {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_with_stmt`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_with_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for WithStmt {
+    #[doc = "Calls [VisitMut`::visit_mut_with_stmt`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_with_stmt(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             WithStmt { span, obj, body } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Obj));
-                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Expr> as VisitMutWith<V>>::visit_mut_with(obj, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Body));
-                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(body, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for YieldExpr {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_yield_expr`] with `self`."]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_yield_expr(visitor, self, __ast_path)
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for YieldExpr {
+    #[doc = "Calls [VisitMut`::visit_mut_yield_expr`] with `self`."]
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_yield_expr(visitor, self)
     }
 
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             YieldExpr {
                 span,
@@ -91946,11412 +64241,14903 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for YieldExpr {
                 delegate,
             } => {
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Span));
-                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <swc_common::Span as VisitMutWith<V>>::visit_mut_with(span, visitor)
                 };
                 {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Arg));
-                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<Expr>> as VisitMutWith<V>>::visit_mut_with(arg, visitor)
                 };
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_atoms::Atom {
+    #[doc = "Calls [VisitMut`::visit_mut_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_atom(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BigIntValue {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_big_int_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for BigIntValue {
+    #[doc = "Calls [VisitMut`::visit_mut_big_int_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_big_int_value(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_big_int_value(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ClassMember> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_members`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ClassMember> {
+    #[doc = "Calls [VisitMut`::visit_mut_class_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_class_members(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_class_members(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ClassMember as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ClassMember as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Decorator> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_decorators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Decorator> {
+    #[doc = "Calls [VisitMut`::visit_mut_decorators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_decorators(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_decorators(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Decorator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Decorator as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ExportSpecifier> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_specifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ExportSpecifier> {
+    #[doc = "Calls [VisitMut`::visit_mut_export_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_export_specifiers(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_export_specifiers(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ExportSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ExportSpecifier as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ExprOrSpread> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ExprOrSpread> {
+    #[doc = "Calls [VisitMut`::visit_mut_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_expr_or_spreads(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ExprOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ExprOrSpread as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Box<Expr>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_exprs`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Box<Expr>> {
+    #[doc = "Calls [VisitMut`::visit_mut_exprs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_exprs(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_exprs(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Box<Expr> as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ImportSpecifier> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_specifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ImportSpecifier> {
+    #[doc = "Calls [VisitMut`::visit_mut_import_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_specifiers(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_specifiers(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ImportSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ImportSpecifier as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ImportWithItem> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_with_items`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ImportWithItem> {
+    #[doc = "Calls [VisitMut`::visit_mut_import_with_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_import_with_items(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_import_with_items(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ImportWithItem as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ImportWithItem as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<JSXAttrOrSpread> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<JSXAttrOrSpread> {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_attr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <JSXAttrOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <JSXAttrOrSpread as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<JSXElementChild> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element_childs`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<JSXElementChild> {
+    #[doc = "Calls [VisitMut`::visit_mut_jsx_element_childs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_jsx_element_childs(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_jsx_element_childs(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <JSXElementChild as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <JSXElementChild as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ModuleItem> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_items`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ModuleItem> {
+    #[doc = "Calls [VisitMut`::visit_mut_module_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_module_items(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_module_items(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ModuleItem as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ModuleItem as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ObjectPatProp> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_pat_props`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ObjectPatProp> {
+    #[doc = "Calls [VisitMut`::visit_mut_object_pat_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_object_pat_props(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_object_pat_props(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ObjectPatProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ObjectPatProp as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Accessibility> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_accessibility`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Accessibility> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_accessibility`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_accessibility(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_accessibility(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Accessibility as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Accessibility as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_atom(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_atom(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<BlockStmt> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_block_stmt`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<BlockStmt> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_block_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_block_stmt(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_block_stmt(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <BlockStmt as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<CatchClause> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_catch_clause`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<CatchClause> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_catch_clause`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_catch_clause(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_catch_clause(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <CatchClause as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <CatchClause as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Expr>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_expr`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Expr>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_expr(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<Expr> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ExprOrSpread> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_expr_or_spread`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ExprOrSpread> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_expr_or_spread`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_expr_or_spread(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <ExprOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ExprOrSpread as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<ExprOrSpread>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<ExprOrSpread>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Vec<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Vec<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Ident> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Ident> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ident(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ident(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Ident as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<JSXAttrValue> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_jsx_attr_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<JSXAttrValue> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_jsx_attr_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_jsx_attr_value(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <JSXAttrValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <JSXAttrValue as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<JSXClosingElement> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_jsx_closing_element`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<JSXClosingElement> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_jsx_closing_element`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_jsx_closing_element(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <JSXClosingElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <JSXClosingElement as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ModuleExportName> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_module_export_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ModuleExportName> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_module_export_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_module_export_name(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_module_export_name(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <ModuleExportName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <ModuleExportName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ObjectLit>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_object_lit`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ObjectLit>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_object_lit`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_object_lit(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_object_lit(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<ObjectLit> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<ObjectLit> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Pat> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_pat`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Pat> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_pat`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_pat(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_pat(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => {
-                <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(inner, visitor, __ast_path)
-            }
+            Some(inner) => <Pat as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_common::Span> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_span`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_common::Span> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_span(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_span(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <swc_common::Span as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Stmt>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_stmt`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Stmt>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_stmt(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_stmt(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Str>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_str`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Str>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_str`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_str(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_str(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<Str> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TruePlusMinus> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_true_plus_minus`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TruePlusMinus> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_true_plus_minus`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_true_plus_minus(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <TruePlusMinus as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <TruePlusMinus as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TsEntityName> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_entity_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TsEntityName> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_entity_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ts_entity_name(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <TsEntityName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TsNamespaceBody> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_namespace_body`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TsNamespaceBody> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_namespace_body`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ts_namespace_body(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <TsNamespaceBody as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <TsNamespaceBody as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsType>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsType>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ts_type(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<TsType> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypeAnn>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type_ann`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeAnn>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type_ann`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ts_type_ann(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <Box<TsTypeAnn> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <Box<TsTypeAnn> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypeParamDecl>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeParamDecl>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ts_type_param_decl(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Box<TsTypeParamDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <Box<TsTypeParamDecl> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypeParamInstantiation>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type_param_instantiation`] with `self`. \
-             (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeParamInstantiation>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_ts_type_param_instantiation`] with `self`. (Extra \
+             impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
-                <Box<TsTypeParamInstantiation> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                    inner, visitor, __ast_path,
-                )
+                <Box<TsTypeParamInstantiation> as VisitMutWith<V>>::visit_mut_with(inner, visitor)
             }
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<VarDeclOrExpr> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<VarDeclOrExpr> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_var_decl_or_expr(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
-            Some(inner) => <VarDeclOrExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                inner, visitor, __ast_path,
-            ),
+            Some(inner) => <VarDeclOrExpr as VisitMutWith<V>>::visit_mut_with(inner, visitor),
             None => {}
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Option<ExprOrSpread>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Option<ExprOrSpread>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Option<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut().for_each(|item| {
+            <Option<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(item, visitor)
         })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Option<Pat>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_vec_pats`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Option<Pat>> {
+    #[doc = "Calls [VisitMut`::visit_mut_opt_vec_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_opt_vec_pats(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_opt_vec_pats(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Option<Pat> as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ParamOrTsParamProp> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_param_or_ts_param_props`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ParamOrTsParamProp> {
+    #[doc = "Calls [VisitMut`::visit_mut_param_or_ts_param_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_param_or_ts_param_props(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <ParamOrTsParamProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <ParamOrTsParamProp as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Param> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Param> {
+    #[doc = "Calls [VisitMut`::visit_mut_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_params(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_params(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Param as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Param as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Pat> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_pats`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Pat> {
+    #[doc = "Calls [VisitMut`::visit_mut_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_pats(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_pats(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Pat as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PropOrSpread> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PropOrSpread> {
+    #[doc = "Calls [VisitMut`::visit_mut_prop_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_prop_or_spreads(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_prop_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <PropOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <PropOrSpread as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::Span {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_span`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_common::Span {
+    #[doc = "Calls [VisitMut`::visit_mut_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_span(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_span(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Stmt> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_stmts`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Stmt> {
+    #[doc = "Calls [VisitMut`::visit_mut_stmts`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_stmts(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_stmts(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Stmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Stmt as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SwitchCase> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_switch_cases`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SwitchCase> {
+    #[doc = "Calls [VisitMut`::visit_mut_switch_cases`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_switch_cases(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_switch_cases(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <SwitchCase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <SwitchCase as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::SyntaxContext {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_syntax_context`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for swc_common::SyntaxContext {
+    #[doc = "Calls [VisitMut`::visit_mut_syntax_context`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_syntax_context(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_syntax_context(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TplElement> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_tpl_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TplElement> {
+    #[doc = "Calls [VisitMut`::visit_mut_tpl_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_tpl_elements(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_tpl_elements(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TplElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <TplElement as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsEnumMember> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_members`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsEnumMember> {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_enum_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_enum_members(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_enum_members(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsEnumMember as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <TsEnumMember as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsExprWithTypeArgs> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsExprWithTypeArgs> {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_expr_with_type_argss(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsExprWithTypeArgs as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <TsExprWithTypeArgs as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsFnParam> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsFnParam> {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_fn_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_fn_params(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_fn_params(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsFnParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <TsFnParam as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTupleElement> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tuple_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTupleElement> {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_tuple_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_tuple_elements(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsTupleElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <TsTupleElement as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTypeElement> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTypeElement> {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_elements(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_elements(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsTypeElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <TsTypeElement as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTypeParam> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTypeParam> {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_type_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_type_params(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_type_params(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <TsTypeParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <TsTypeParam as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Box<TsType>> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Box<TsType>> {
+    #[doc = "Calls [VisitMut`::visit_mut_ts_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_ts_types(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_ts_types(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <Box<TsType> as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<VarDeclarator> {
-    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_declarators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<VarDeclarator> {
+    #[doc = "Calls [VisitMut`::visit_mut_var_declarators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        <V as VisitMutAstPath>::visit_mut_var_declarators(visitor, self, __ast_path)
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        <V as VisitMut>::visit_mut_var_declarators(visitor, self)
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        self.iter_mut().enumerate().for_each(|(__idx, item)| {
-            let mut __ast_path = __ast_path.with_index_guard(__idx);
-            <VarDeclarator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-                item,
-                visitor,
-                &mut *__ast_path,
-            )
-        })
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        self.iter_mut()
+            .for_each(|item| <VarDeclarator as VisitMutWith<V>>::visit_mut_with(item, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> VisitMutWithAstPath<V> for std::boxed::Box<T>
+impl<V, T> VisitMutWith<V> for std::boxed::Box<T>
 where
-    V: ?Sized + VisitMutAstPath,
-    T: VisitMutWithAstPath<V>,
+    V: ?Sized + VisitMut,
+    T: VisitMutWith<V>,
 {
     #[inline]
-    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        let v = <T as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
-            &mut **self,
-            visitor,
-            __ast_path,
-        );
+    fn visit_mut_with(&mut self, visitor: &mut V) {
+        let v = <T as VisitMutWith<V>>::visit_mut_with(&mut **self, visitor);
         v
     }
 
     #[inline]
-    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
-        let v = <T as VisitMutWithAstPath<V>>::visit_mut_children_with_ast_path(
-            &mut **self,
-            visitor,
-            __ast_path,
-        );
+    fn visit_mut_children_with(&mut self, visitor: &mut V) {
+        let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
         v
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-pub trait Fold {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Accessibility`.\n\nBy default, this method calls \
-             [`Accessibility::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Accessibility::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
-        <Accessibility as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
+        <Accessibility as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ArrayLit`.\n\nBy default, this method calls \
-             [`ArrayLit::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ArrayLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
-        <ArrayLit as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
+        <ArrayLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ArrayPat`.\n\nBy default, this method calls \
-             [`ArrayPat::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ArrayPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
-        <ArrayPat as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
+        <ArrayPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ArrowExpr`.\n\nBy default, this method calls \
-             [`ArrowExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ArrowExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
-        <ArrowExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
+        <ArrowExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignExpr`.\n\nBy default, this method calls \
-             [`AssignExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
-        <AssignExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
+        <AssignExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignOp`.\n\nBy default, this method calls \
-             [`AssignOp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
-        <AssignOp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
+        <AssignOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignPat`.\n\nBy default, this method calls \
-             [`AssignPat::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
-        <AssignPat as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
+        <AssignPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignPatProp`.\n\nBy default, this method calls \
-             [`AssignPatProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignPatProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
-        <AssignPatProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_assign_pat_prop(
+        &mut self,
+        node: &mut AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AssignPatProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignProp`.\n\nBy default, this method calls \
-             [`AssignProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
-        <AssignProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
+        <AssignProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignTarget`.\n\nBy default, this method calls \
-             [`AssignTarget::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignTarget::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
-        <AssignTarget as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
+        <AssignTarget as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignTargetPat`.\n\nBy default, this method calls \
-             [`AssignTargetPat::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AssignTargetPat::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
-        <AssignTargetPat as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_assign_target_pat(
+        &mut self,
+        node: &mut AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <AssignTargetPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`swc_atoms :: Atom::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
-        <swc_atoms::Atom as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+        <swc_atoms::Atom as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AutoAccessor`.\n\nBy default, this method calls \
-             [`AutoAccessor::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AutoAccessor::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
-        <AutoAccessor as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
+        <AutoAccessor as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AwaitExpr`.\n\nBy default, this method calls \
-             [`AwaitExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`AwaitExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
-        <AwaitExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
+        <AwaitExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BigInt`.\n\nBy default, this method calls \
-             [`BigInt::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`BigInt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
-        <BigInt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
+        <BigInt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BigIntValue`.\n\nBy default, this method calls \
-             [`BigIntValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BigIntValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
-        <BigIntValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
+        <BigIntValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BinExpr`.\n\nBy default, this method calls \
-             [`BinExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`BinExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
-        <BinExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
+        <BinExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BinaryOp`.\n\nBy default, this method calls \
-             [`BinaryOp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BinaryOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
-        <BinaryOp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
+        <BinaryOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BindingIdent`.\n\nBy default, this method calls \
-             [`BindingIdent::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BindingIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
-        <BindingIdent as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
+        <BindingIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BlockStmt`.\n\nBy default, this method calls \
-             [`BlockStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BlockStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
-        <BlockStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
+        <BlockStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BlockStmtOrExpr`.\n\nBy default, this method calls \
-             [`BlockStmtOrExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BlockStmtOrExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
-        <BlockStmtOrExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_block_stmt_or_expr(
+        &mut self,
+        node: &mut BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <BlockStmtOrExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Bool`.\n\nBy default, this method calls \
-             [`Bool::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Bool::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_bool(&mut self, node: Bool) -> Bool {
-        <Bool as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
+        <Bool as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `BreakStmt`.\n\nBy default, this method calls \
-             [`BreakStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BreakStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
-        <BreakStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
+        <BreakStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CallExpr`.\n\nBy default, this method calls \
-             [`CallExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CallExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
-        <CallExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
+        <CallExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Callee`.\n\nBy default, this method calls \
-             [`Callee::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Callee::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_callee(&mut self, node: Callee) -> Callee {
-        <Callee as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
+        <Callee as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CatchClause`.\n\nBy default, this method calls \
-             [`CatchClause::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CatchClause::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
-        <CatchClause as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
+        <CatchClause as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Class`.\n\nBy default, this method calls \
-             [`Class::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Class::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_class(&mut self, node: Class) -> Class {
-        <Class as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
+        <Class as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassDecl`.\n\nBy default, this method calls \
-             [`ClassDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
-        <ClassDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
+        <ClassDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassExpr`.\n\nBy default, this method calls \
-             [`ClassExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
-        <ClassExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
+        <ClassExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassMember`.\n\nBy default, this method calls \
-             [`ClassMember::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassMember::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
-        <ClassMember as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
+        <ClassMember as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ClassMember >`.\n\nBy default, this method calls [`Vec < \
-             ClassMember >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             ClassMember >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
-        <Vec<ClassMember> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class_members(
+        &mut self,
+        node: &mut Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ClassMember> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassMethod`.\n\nBy default, this method calls \
-             [`ClassMethod::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassMethod::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
-        <ClassMethod as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
+        <ClassMethod as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassProp`.\n\nBy default, this method calls \
-             [`ClassProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ClassProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
-        <ClassProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
+        <ClassProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ComputedPropName`.\n\nBy default, this method calls \
-             [`ComputedPropName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ComputedPropName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
-        <ComputedPropName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_computed_prop_name(
+        &mut self,
+        node: &mut ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ComputedPropName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CondExpr`.\n\nBy default, this method calls \
-             [`CondExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`CondExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
-        <CondExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
+        <CondExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Constructor`.\n\nBy default, this method calls \
-             [`Constructor::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Constructor::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
-        <Constructor as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
+        <Constructor as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ContinueStmt`.\n\nBy default, this method calls \
-             [`ContinueStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ContinueStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
-        <ContinueStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
+        <ContinueStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DebuggerStmt`.\n\nBy default, this method calls \
-             [`DebuggerStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DebuggerStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
-        <DebuggerStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
+        <DebuggerStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Decl`.\n\nBy default, this method calls \
-             [`Decl::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Decl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_decl(&mut self, node: Decl) -> Decl {
-        <Decl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
+        <Decl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Decorator`.\n\nBy default, this method calls \
-             [`Decorator::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Decorator::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
-        <Decorator as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
+        <Decorator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Decorator >`.\n\nBy default, this method calls [`Vec < \
-             Decorator >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             Decorator >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
-        <Vec<Decorator> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
+        <Vec<Decorator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DefaultDecl`.\n\nBy default, this method calls \
-             [`DefaultDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DefaultDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
-        <DefaultDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
+        <DefaultDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DoWhileStmt`.\n\nBy default, this method calls \
-             [`DoWhileStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`DoWhileStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
-        <DoWhileStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
+        <DoWhileStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `EmptyStmt`.\n\nBy default, this method calls \
-             [`EmptyStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`EmptyStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
-        <EmptyStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
+        <EmptyStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `EsVersion`.\n\nBy default, this method calls \
-             [`EsVersion::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`EsVersion::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
-        <EsVersion as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
+        <EsVersion as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportAll`.\n\nBy default, this method calls \
-             [`ExportAll::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExportAll::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
-        <ExportAll as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
+        <ExportAll as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDecl`.\n\nBy default, this method calls \
-             [`ExportDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExportDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
-        <ExportDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
+        <ExportDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDefaultDecl`.\n\nBy default, this method calls \
-             [`ExportDefaultDecl::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ExportDefaultDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
-        <ExportDefaultDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_export_default_decl(
+        &mut self,
+        node: &mut ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ExportDefaultDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDefaultExpr`.\n\nBy default, this method calls \
-             [`ExportDefaultExpr::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ExportDefaultExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
-        <ExportDefaultExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_export_default_expr(
+        &mut self,
+        node: &mut ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ExportDefaultExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ExportDefaultSpecifier::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportDefaultSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_export_default_specifier(
+    fn visit_mut_export_default_specifier(
         &mut self,
-        node: ExportDefaultSpecifier,
-    ) -> ExportDefaultSpecifier {
-        <ExportDefaultSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ExportDefaultSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamedSpecifier::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportNamedSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
-        <ExportNamedSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_export_named_specifier(
+        &mut self,
+        node: &mut ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ExportNamedSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportNamespaceSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamespaceSpecifier::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportNamespaceSpecifier::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_export_namespace_specifier(
+    fn visit_mut_export_namespace_specifier(
         &mut self,
-        node: ExportNamespaceSpecifier,
-    ) -> ExportNamespaceSpecifier {
-        <ExportNamespaceSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ExportNamespaceSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportSpecifier`.\n\nBy default, this method calls \
-             [`ExportSpecifier::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExportSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
-        <ExportSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_export_specifier(
+        &mut self,
+        node: &mut ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ExportSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ExportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ExportSpecifier >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < ExportSpecifier >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
-        <Vec<ExportSpecifier> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_export_specifiers(
+        &mut self,
+        node: &mut Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ExportSpecifier> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Expr`.\n\nBy default, this method calls \
-             [`Expr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Expr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_expr(&mut self, node: Expr) -> Expr {
-        <Expr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
+        <Expr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExprOrSpread`.\n\nBy default, this method calls \
-             [`ExprOrSpread::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExprOrSpread::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
-        <ExprOrSpread as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
+        <ExprOrSpread as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ExprOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             ExprOrSpread >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             ExprOrSpread >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
-        <Vec<ExprOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_expr_or_spreads(
+        &mut self,
+        node: &mut Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ExprOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExprStmt`.\n\nBy default, this method calls \
-             [`ExprStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ExprStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
-        <ExprStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
+        <ExprStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Box < Expr > >`.\n\nBy default, this method calls [`Vec < \
-             Box < Expr > >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             Box < Expr > >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
-        <Vec<Box<Expr>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
+        <Vec<Box<Expr>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FnDecl`.\n\nBy default, this method calls \
-             [`FnDecl::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`FnDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
-        <FnDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
+        <FnDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FnExpr`.\n\nBy default, this method calls \
-             [`FnExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`FnExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
-        <FnExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
+        <FnExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForHead`.\n\nBy default, this method calls \
-             [`ForHead::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`ForHead::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
-        <ForHead as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
+        <ForHead as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForInStmt`.\n\nBy default, this method calls \
-             [`ForInStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForInStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
-        <ForInStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
+        <ForInStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForOfStmt`.\n\nBy default, this method calls \
-             [`ForOfStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForOfStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
-        <ForOfStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
+        <ForOfStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ForStmt`.\n\nBy default, this method calls \
-             [`ForStmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`ForStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
-        <ForStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
+        <ForStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Function::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
-        <Function as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+        <Function as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `GetterProp`.\n\nBy default, this method calls \
-             [`GetterProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`GetterProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
-        <GetterProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
+        <GetterProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Ident::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
-        <Ident as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+        <Ident as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `IdentName`.\n\nBy default, this method calls \
-             [`IdentName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`IdentName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
-        <IdentName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
+        <IdentName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `IfStmt`.\n\nBy default, this method calls \
-             [`IfStmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`IfStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
-        <IfStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
+        <IfStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Import`.\n\nBy default, this method calls \
-             [`Import::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Import::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_import(&mut self, node: Import) -> Import {
-        <Import as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
+        <Import as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportDecl`.\n\nBy default, this method calls \
-             [`ImportDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
-        <ImportDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
+        <ImportDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ImportDefaultSpecifier::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportDefaultSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_import_default_specifier(
+    fn visit_mut_import_default_specifier(
         &mut self,
-        node: ImportDefaultSpecifier,
-    ) -> ImportDefaultSpecifier {
-        <ImportDefaultSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ImportDefaultSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ImportNamedSpecifier::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportNamedSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
-        <ImportNamedSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_named_specifier(
+        &mut self,
+        node: &mut ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ImportNamedSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportPhase`.\n\nBy default, this method calls \
-             [`ImportPhase::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportPhase::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
-        <ImportPhase as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
+        <ImportPhase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportSpecifier`.\n\nBy default, this method calls \
-             [`ImportSpecifier::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
-        <ImportSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_specifier(
+        &mut self,
+        node: &mut ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ImportSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ImportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ImportSpecifier >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < ImportSpecifier >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
-        <Vec<ImportSpecifier> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_specifiers(
+        &mut self,
+        node: &mut Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ImportSpecifier> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportStarAsSpecifier`.\n\nBy default, this method calls \
-             [`ImportStarAsSpecifier::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportStarAsSpecifier::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_import_star_as_specifier(
+    fn visit_mut_import_star_as_specifier(
         &mut self,
-        node: ImportStarAsSpecifier,
-    ) -> ImportStarAsSpecifier {
-        <ImportStarAsSpecifier as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ImportStarAsSpecifier as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportWith`.\n\nBy default, this method calls \
-             [`ImportWith::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportWith::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
-        <ImportWith as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
+        <ImportWith as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
-             [`ImportWithItem::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ImportWithItem::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
-        <ImportWithItem as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_with_item(
+        &mut self,
+        node: &mut ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ImportWithItem as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ImportWithItem >`.\n\nBy default, this method calls [`Vec \
-             < ImportWithItem >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < ImportWithItem >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
-        <Vec<ImportWithItem> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_import_with_items(
+        &mut self,
+        node: &mut Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ImportWithItem> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Invalid`.\n\nBy default, this method calls \
-             [`Invalid::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Invalid::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
-        <Invalid as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
+        <Invalid as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXAttr`.\n\nBy default, this method calls \
-             [`JSXAttr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`JSXAttr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
-        <JSXAttr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
+        <JSXAttr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXAttrName`.\n\nBy default, this method calls \
-             [`JSXAttrName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXAttrName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
-        <JSXAttrName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
+        <JSXAttrName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXAttrOrSpread`.\n\nBy default, this method calls \
-             [`JSXAttrOrSpread::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXAttrOrSpread::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
-        <JSXAttrOrSpread as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_attr_or_spread(
+        &mut self,
+        node: &mut JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXAttrOrSpread as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < JSXAttrOrSpread >`.\n\nBy default, this method calls \
-             [`Vec < JSXAttrOrSpread >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < JSXAttrOrSpread >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
-        <Vec<JSXAttrOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_attr_or_spreads(
+        &mut self,
+        node: &mut Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<JSXAttrOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXAttrValue`.\n\nBy default, this method calls \
-             [`JSXAttrValue::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXAttrValue::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
-        <JSXAttrValue as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
+        <JSXAttrValue as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXClosingElement`.\n\nBy default, this method calls \
-             [`JSXClosingElement::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXClosingElement::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
-        <JSXClosingElement as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_closing_element(
+        &mut self,
+        node: &mut JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXClosingElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXClosingFragment`.\n\nBy default, this method calls \
-             [`JSXClosingFragment::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXClosingFragment::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
-        <JSXClosingFragment as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_closing_fragment(
+        &mut self,
+        node: &mut JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXClosingFragment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXElement`.\n\nBy default, this method calls \
-             [`JSXElement::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
-        <JSXElement as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
+        <JSXElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXElementChild`.\n\nBy default, this method calls \
-             [`JSXElementChild::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXElementChild::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
-        <JSXElementChild as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_element_child(
+        &mut self,
+        node: &mut JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXElementChild as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < JSXElementChild >`.\n\nBy default, this method calls \
-             [`Vec < JSXElementChild >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Vec < JSXElementChild >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
-        <Vec<JSXElementChild> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_element_childs(
+        &mut self,
+        node: &mut Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<JSXElementChild> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXElementName`.\n\nBy default, this method calls \
-             [`JSXElementName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXElementName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
-        <JSXElementName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_element_name(
+        &mut self,
+        node: &mut JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXElementName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXEmptyExpr`.\n\nBy default, this method calls \
-             [`JSXEmptyExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXEmptyExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
-        <JSXEmptyExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
+        <JSXEmptyExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXExpr`.\n\nBy default, this method calls \
-             [`JSXExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`JSXExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
-        <JSXExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
+        <JSXExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
-    #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
-             [`JSXExprContainer::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+    #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
+             [`JSXExprContainer::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
-        <JSXExprContainer as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_expr_container(
+        &mut self,
+        node: &mut JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXExprContainer as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXFragment`.\n\nBy default, this method calls \
-             [`JSXFragment::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXFragment::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
-        <JSXFragment as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
+        <JSXFragment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXMemberExpr`.\n\nBy default, this method calls \
-             [`JSXMemberExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXMemberExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
-        <JSXMemberExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_member_expr(
+        &mut self,
+        node: &mut JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXMemberExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXNamespacedName`.\n\nBy default, this method calls \
-             [`JSXNamespacedName::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXNamespacedName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
-        <JSXNamespacedName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_namespaced_name(
+        &mut self,
+        node: &mut JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXNamespacedName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXObject`.\n\nBy default, this method calls \
-             [`JSXObject::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXObject::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
-        <JSXObject as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
+        <JSXObject as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXOpeningElement`.\n\nBy default, this method calls \
-             [`JSXOpeningElement::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXOpeningElement::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
-        <JSXOpeningElement as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_opening_element(
+        &mut self,
+        node: &mut JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXOpeningElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXOpeningFragment`.\n\nBy default, this method calls \
-             [`JSXOpeningFragment::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXOpeningFragment::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
-        <JSXOpeningFragment as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_opening_fragment(
+        &mut self,
+        node: &mut JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXOpeningFragment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXSpreadChild`.\n\nBy default, this method calls \
-             [`JSXSpreadChild::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXSpreadChild::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
-        <JSXSpreadChild as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_spread_child(
+        &mut self,
+        node: &mut JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <JSXSpreadChild as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXText`.\n\nBy default, this method calls \
-             [`JSXText::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`JSXText::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
-        <JSXText as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
+        <JSXText as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Key`.\n\nBy default, this method calls \
-             [`Key::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Key::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_key(&mut self, node: Key) -> Key {
-        <Key as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
+        <Key as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `KeyValuePatProp`.\n\nBy default, this method calls \
-             [`KeyValuePatProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`KeyValuePatProp::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
-        <KeyValuePatProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_key_value_pat_prop(
+        &mut self,
+        node: &mut KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <KeyValuePatProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyValueProp`.\n\nBy default, this method calls \
-             [`KeyValueProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`KeyValueProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
-        <KeyValueProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
+        <KeyValueProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `LabeledStmt`.\n\nBy default, this method calls \
-             [`LabeledStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`LabeledStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
-        <LabeledStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
+        <LabeledStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Lit`.\n\nBy default, this method calls \
-             [`Lit::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Lit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_lit(&mut self, node: Lit) -> Lit {
-        <Lit as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
+        <Lit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MemberExpr`.\n\nBy default, this method calls \
-             [`MemberExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MemberExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
-        <MemberExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
+        <MemberExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MemberProp`.\n\nBy default, this method calls \
-             [`MemberProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MemberProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
-        <MemberProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
+        <MemberProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MetaPropExpr`.\n\nBy default, this method calls \
-             [`MetaPropExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MetaPropExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
-        <MetaPropExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
+        <MetaPropExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MetaPropKind`.\n\nBy default, this method calls \
-             [`MetaPropKind::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MetaPropKind::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
-        <MetaPropKind as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
+        <MetaPropKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MethodKind`.\n\nBy default, this method calls \
-             [`MethodKind::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MethodKind::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
-        <MethodKind as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
+        <MethodKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `MethodProp`.\n\nBy default, this method calls \
-             [`MethodProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`MethodProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
-        <MethodProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
+        <MethodProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Module`.\n\nBy default, this method calls \
-             [`Module::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Module::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_module(&mut self, node: Module) -> Module {
-        <Module as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
+        <Module as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ModuleDecl`.\n\nBy default, this method calls \
-             [`ModuleDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ModuleDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
-        <ModuleDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
+        <ModuleDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ModuleExportName`.\n\nBy default, this method calls \
-             [`ModuleExportName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ModuleExportName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
-        <ModuleExportName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_module_export_name(
+        &mut self,
+        node: &mut ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ModuleExportName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ModuleItem`.\n\nBy default, this method calls \
-             [`ModuleItem::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ModuleItem::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
-        <ModuleItem as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
+        <ModuleItem as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ModuleItem >`.\n\nBy default, this method calls [`Vec < \
-             ModuleItem >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             ModuleItem >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
-        <Vec<ModuleItem> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
+        <Vec<ModuleItem> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamedExport`.\n\nBy default, this method calls \
-             [`NamedExport::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NamedExport::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
-        <NamedExport as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
+        <NamedExport as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NewExpr`.\n\nBy default, this method calls \
-             [`NewExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`NewExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
-        <NewExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
+        <NewExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Null`.\n\nBy default, this method calls \
-             [`Null::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Null::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_null(&mut self, node: Null) -> Null {
-        <Null as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
+        <Null as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Number::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
-        <Number as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+        <Number as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ObjectLit`.\n\nBy default, this method calls \
-             [`ObjectLit::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ObjectLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
-        <ObjectLit as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
+        <ObjectLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ObjectPat`.\n\nBy default, this method calls \
-             [`ObjectPat::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ObjectPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
-        <ObjectPat as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
+        <ObjectPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ObjectPatProp`.\n\nBy default, this method calls \
-             [`ObjectPatProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ObjectPatProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
-        <ObjectPatProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_object_pat_prop(
+        &mut self,
+        node: &mut ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ObjectPatProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ObjectPatProp >`.\n\nBy default, this method calls [`Vec \
-             < ObjectPatProp >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < ObjectPatProp >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
-        <Vec<ObjectPatProp> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_object_pat_props(
+        &mut self,
+        node: &mut Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ObjectPatProp> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Accessibility >`.\n\nBy default, this method calls \
-             [`Option < Accessibility >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < Accessibility >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
-        <Option<Accessibility> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_accessibility(
+        &mut self,
+        node: &mut Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Accessibility> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::fold_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < swc_atoms :: Atom >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
-        <Option<swc_atoms::Atom> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<swc_atoms::Atom> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < BlockStmt >`.\n\nBy default, this method calls \
-             [`Option < BlockStmt >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < BlockStmt >::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
-        <Option<BlockStmt> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_block_stmt(
+        &mut self,
+        node: &mut Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<BlockStmt> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptCall`.\n\nBy default, this method calls \
-             [`OptCall::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`OptCall::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
-        <OptCall as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
+        <OptCall as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
-             [`Option < CatchClause >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < CatchClause >::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
-        <Option<CatchClause> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_catch_clause(
+        &mut self,
+        node: &mut Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<CatchClause> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptChainBase`.\n\nBy default, this method calls \
-             [`OptChainBase::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`OptChainBase::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
-        <OptChainBase as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
+        <OptChainBase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptChainExpr`.\n\nBy default, this method calls \
-             [`OptChainExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`OptChainExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
-        <OptChainExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
+        <OptChainExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Expr > >`.\n\nBy default, this method calls \
-             [`Option < Box < Expr > >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < Box < Expr > >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
-        <Option<Box<Expr>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
+        <Option<Box<Expr>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ExprOrSpread >`.\n\nBy default, this method calls \
-             [`Option < ExprOrSpread >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < ExprOrSpread >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
-        <Option<ExprOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_expr_or_spread(
+        &mut self,
+        node: &mut Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<ExprOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Option < Vec < ExprOrSpread > >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Vec < ExprOrSpread > >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_expr_or_spreads(
+    fn visit_mut_opt_expr_or_spreads(
         &mut self,
-        node: Option<Vec<ExprOrSpread>>,
-    ) -> Option<Vec<ExprOrSpread>> {
-        <Option<Vec<ExprOrSpread>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Vec<ExprOrSpread>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             Ident >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
-        <Option<Ident> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+        <Option<Ident> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
-             [`Option < JSXAttrValue >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < JSXAttrValue >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
-        <Option<JSXAttrValue> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_jsx_attr_value(
+        &mut self,
+        node: &mut Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<JSXAttrValue> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < JSXClosingElement >`.\n\nBy default, this method calls \
-             [`Option < JSXClosingElement >::fold_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < JSXClosingElement >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_jsx_closing_element(
+    fn visit_mut_opt_jsx_closing_element(
         &mut self,
-        node: Option<JSXClosingElement>,
-    ) -> Option<JSXClosingElement> {
-        <Option<JSXClosingElement> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<JSXClosingElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ModuleExportName >`.\n\nBy default, this method calls \
-             [`Option < ModuleExportName >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < ModuleExportName >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_module_export_name(
+    fn visit_mut_opt_module_export_name(
         &mut self,
-        node: Option<ModuleExportName>,
-    ) -> Option<ModuleExportName> {
-        <Option<ModuleExportName> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<ModuleExportName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < ObjectLit > >`.\n\nBy default, this method calls \
-             [`Option < Box < ObjectLit > >::fold_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < ObjectLit > >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
-        <Option<Box<ObjectLit>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_object_lit(
+        &mut self,
+        node: &mut Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<ObjectLit>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Pat >`.\n\nBy default, this method calls [`Option < \
-             Pat >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             Pat >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
-        <Option<Pat> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
+        <Option<Pat> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < swc_common :: Span >`.\n\nBy default, this method \
-             calls [`Option < swc_common :: Span >::fold_children_with`]. If you want to recurse, \
-             you need to call it manually."]
+             calls [`Option < swc_common :: Span >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
-        <Option<swc_common::Span> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_span(
+        &mut self,
+        node: &mut Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<swc_common::Span> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Stmt > >`.\n\nBy default, this method calls \
-             [`Option < Box < Stmt > >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < Box < Stmt > >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
-        <Option<Box<Stmt>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
+        <Option<Box<Stmt>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Str > >`.\n\nBy default, this method calls \
-             [`Option < Box < Str > >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < Box < Str > >::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
-        <Option<Box<Str>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
+        <Option<Box<Str>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TruePlusMinus >`.\n\nBy default, this method calls \
-             [`Option < TruePlusMinus >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < TruePlusMinus >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
-        <Option<TruePlusMinus> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_true_plus_minus(
+        &mut self,
+        node: &mut Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<TruePlusMinus> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TsEntityName >`.\n\nBy default, this method calls \
-             [`Option < TsEntityName >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < TsEntityName >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
-        <Option<TsEntityName> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_ts_entity_name(
+        &mut self,
+        node: &mut Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<TsEntityName> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TsNamespaceBody >`.\n\nBy default, this method calls \
-             [`Option < TsNamespaceBody >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < TsNamespaceBody >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_ts_namespace_body(
+    fn visit_mut_opt_ts_namespace_body(
         &mut self,
-        node: Option<TsNamespaceBody>,
-    ) -> Option<TsNamespaceBody> {
-        <Option<TsNamespaceBody> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<TsNamespaceBody> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsType > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsType > >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Option < Box < TsType > >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
-        <Option<Box<TsType>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_ts_type(
+        &mut self,
+        node: &mut Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<TsType>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeAnn > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsTypeAnn > >::fold_children_with`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < TsTypeAnn > >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
-        <Option<Box<TsTypeAnn>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_ts_type_ann(
+        &mut self,
+        node: &mut Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamDecl > >`.\n\nBy default, this method \
-             calls [`Option < Box < TsTypeParamDecl > >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < Box < TsTypeParamDecl > >::visit_mut_children_with_ast_path`]. If \
+             you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_ts_type_param_decl(
+    fn visit_mut_opt_ts_type_param_decl(
         &mut self,
-        node: Option<Box<TsTypeParamDecl>>,
-    ) -> Option<Box<TsTypeParamDecl>> {
-        <Option<Box<TsTypeParamDecl>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamInstantiation > >`.\n\nBy default, \
              this method calls [`Option < Box < TsTypeParamInstantiation > \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_ts_type_param_instantiation(
+    fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
-        node: Option<Box<TsTypeParamInstantiation>>,
-    ) -> Option<Box<TsTypeParamInstantiation>> {
-        <Option<Box<TsTypeParamInstantiation>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < Self > > :: visit_mut_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < VarDeclOrExpr >`.\n\nBy default, this method calls \
-             [`Option < VarDeclOrExpr >::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Option < VarDeclOrExpr >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
-        <Option<VarDeclOrExpr> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_var_decl_or_expr(
+        &mut self,
+        node: &mut Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Option<VarDeclOrExpr> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Option < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Vec < Option < ExprOrSpread > >::fold_children_with`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Vec < Option < ExprOrSpread > >::visit_mut_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_vec_expr_or_spreads(
+    fn visit_mut_opt_vec_expr_or_spreads(
         &mut self,
-        node: Vec<Option<ExprOrSpread>>,
-    ) -> Vec<Option<ExprOrSpread>> {
-        <Vec<Option<ExprOrSpread>> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<Option<ExprOrSpread>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Option < Pat > >`.\n\nBy default, this method calls [`Vec \
-             < Option < Pat > >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < Option < Pat > >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
-        <Vec<Option<Pat>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_opt_vec_pats(
+        &mut self,
+        node: &mut Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<Option<Pat>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Param`.\n\nBy default, this method calls \
-             [`Param::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Param::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_param(&mut self, node: Param) -> Param {
-        <Param as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
+        <Param as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ParamOrTsParamProp`.\n\nBy default, this method calls \
-             [`ParamOrTsParamProp::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ParamOrTsParamProp::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
-        <ParamOrTsParamProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_param_or_ts_param_prop(
+        &mut self,
+        node: &mut ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <ParamOrTsParamProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ParamOrTsParamProp >`.\n\nBy default, this method calls \
-             [`Vec < ParamOrTsParamProp >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Vec < ParamOrTsParamProp >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_param_or_ts_param_props(
+    fn visit_mut_param_or_ts_param_props(
         &mut self,
-        node: Vec<ParamOrTsParamProp>,
-    ) -> Vec<ParamOrTsParamProp> {
-        <Vec<ParamOrTsParamProp> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<ParamOrTsParamProp> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Param >`.\n\nBy default, this method calls [`Vec < Param \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
-        <Vec<Param> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
+        <Vec<Param> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ParenExpr`.\n\nBy default, this method calls \
-             [`ParenExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ParenExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
-        <ParenExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
+        <ParenExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Pat`.\n\nBy default, this method calls \
-             [`Pat::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Pat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_pat(&mut self, node: Pat) -> Pat {
-        <Pat as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
+        <Pat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Pat >`.\n\nBy default, this method calls [`Vec < Pat \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
-        <Vec<Pat> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
+        <Vec<Pat> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PrivateMethod`.\n\nBy default, this method calls \
-             [`PrivateMethod::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PrivateMethod::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
-        <PrivateMethod as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
+        <PrivateMethod as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PrivateName`.\n\nBy default, this method calls \
-             [`PrivateName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PrivateName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
-        <PrivateName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
+        <PrivateName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PrivateProp`.\n\nBy default, this method calls \
-             [`PrivateProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PrivateProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
-        <PrivateProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
+        <PrivateProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Program`.\n\nBy default, this method calls \
-             [`Program::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Program::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_program(&mut self, node: Program) -> Program {
-        <Program as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
+        <Program as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Prop`.\n\nBy default, this method calls \
-             [`Prop::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Prop::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_prop(&mut self, node: Prop) -> Prop {
-        <Prop as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
+        <Prop as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PropName`.\n\nBy default, this method calls \
-             [`PropName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PropName::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName) -> PropName {
-        <PropName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
+        <PropName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PropOrSpread`.\n\nBy default, this method calls \
-             [`PropOrSpread::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`PropOrSpread::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
-        <PropOrSpread as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
+        <PropOrSpread as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             PropOrSpread >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             PropOrSpread >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
-        <Vec<PropOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_prop_or_spreads(
+        &mut self,
+        node: &mut Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<PropOrSpread> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
-             [`Regex::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Regex::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_regex(&mut self, node: Regex) -> Regex {
-        <Regex as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
+        <Regex as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `RestPat`.\n\nBy default, this method calls \
-             [`RestPat::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`RestPat::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
-        <RestPat as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
+        <RestPat as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ReturnStmt`.\n\nBy default, this method calls \
-             [`ReturnStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ReturnStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
-        <ReturnStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
+        <ReturnStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Script`.\n\nBy default, this method calls \
-             [`Script::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Script::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_script(&mut self, node: Script) -> Script {
-        <Script as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
+        <Script as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SeqExpr`.\n\nBy default, this method calls \
-             [`SeqExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`SeqExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
-        <SeqExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
+        <SeqExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SetterProp`.\n\nBy default, this method calls \
-             [`SetterProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SetterProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
-        <SetterProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
+        <SetterProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SimpleAssignTarget`.\n\nBy default, this method calls \
-             [`SimpleAssignTarget::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SimpleAssignTarget::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
-        <SimpleAssignTarget as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_simple_assign_target(
+        &mut self,
+        node: &mut SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SimpleAssignTarget as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`swc_common :: Span::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
-        <swc_common::Span as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+        <swc_common::Span as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SpreadElement`.\n\nBy default, this method calls \
-             [`SpreadElement::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SpreadElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
-        <SpreadElement as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
+        <SpreadElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `StaticBlock`.\n\nBy default, this method calls \
-             [`StaticBlock::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`StaticBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
-        <StaticBlock as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
+        <StaticBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Stmt`.\n\nBy default, this method calls \
-             [`Stmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Stmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
-        <Stmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
+        <Stmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Stmt >`.\n\nBy default, this method calls [`Vec < Stmt \
-             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
-        <Vec<Stmt> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
+        <Vec<Stmt> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Str::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
-        <Str as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+        <Str as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Super`.\n\nBy default, this method calls \
-             [`Super::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Super::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_super(&mut self, node: Super) -> Super {
-        <Super as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
+        <Super as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SuperProp`.\n\nBy default, this method calls \
-             [`SuperProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SuperProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
-        <SuperProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
+        <SuperProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SuperPropExpr`.\n\nBy default, this method calls \
-             [`SuperPropExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SuperPropExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
-        <SuperPropExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_super_prop_expr(
+        &mut self,
+        node: &mut SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <SuperPropExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SwitchCase`.\n\nBy default, this method calls \
-             [`SwitchCase::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SwitchCase::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
-        <SwitchCase as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
+        <SwitchCase as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < SwitchCase >`.\n\nBy default, this method calls [`Vec < \
-             SwitchCase >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             SwitchCase >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
-        <Vec<SwitchCase> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
+        <Vec<SwitchCase> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SwitchStmt`.\n\nBy default, this method calls \
-             [`SwitchStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SwitchStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
-        <SwitchStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
+        <SwitchStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_common :: SyntaxContext`.\n\nBy default, this method calls \
-             [`swc_common :: SyntaxContext::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`swc_common :: SyntaxContext::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_syntax_context(
+    fn visit_mut_syntax_context(
         &mut self,
-        node: swc_common::SyntaxContext,
-    ) -> swc_common::SyntaxContext {
-        <swc_common::SyntaxContext as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <swc_common::SyntaxContext as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TaggedTpl`.\n\nBy default, this method calls \
-             [`TaggedTpl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TaggedTpl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
-        <TaggedTpl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
+        <TaggedTpl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ThisExpr`.\n\nBy default, this method calls \
-             [`ThisExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ThisExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
-        <ThisExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
+        <ThisExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ThrowStmt`.\n\nBy default, this method calls \
-             [`ThrowStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ThrowStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
-        <ThrowStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
+        <ThrowStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Tpl`.\n\nBy default, this method calls \
-             [`Tpl::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`Tpl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
-        <Tpl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
+        <Tpl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TplElement`.\n\nBy default, this method calls \
-             [`TplElement::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TplElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
-        <TplElement as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
+        <TplElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TplElement >`.\n\nBy default, this method calls [`Vec < \
-             TplElement >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             TplElement >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
-        <Vec<TplElement> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
+        <Vec<TplElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TruePlusMinus`.\n\nBy default, this method calls \
-             [`TruePlusMinus::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TruePlusMinus::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
-        <TruePlusMinus as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_true_plus_minus(
+        &mut self,
+        node: &mut TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TruePlusMinus as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TryStmt`.\n\nBy default, this method calls \
-             [`TryStmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`TryStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
-        <TryStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
+        <TryStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsArrayType`.\n\nBy default, this method calls \
-             [`TsArrayType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsArrayType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
-        <TsArrayType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
+        <TsArrayType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsAsExpr`.\n\nBy default, this method calls \
-             [`TsAsExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsAsExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
-        <TsAsExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
+        <TsAsExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsCallSignatureDecl`.\n\nBy default, this method calls \
-             [`TsCallSignatureDecl::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsCallSignatureDecl::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
-        <TsCallSignatureDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_call_signature_decl(
+        &mut self,
+        node: &mut TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsCallSignatureDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConditionalType`.\n\nBy default, this method calls \
-             [`TsConditionalType::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsConditionalType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
-        <TsConditionalType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_conditional_type(
+        &mut self,
+        node: &mut TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsConditionalType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstAssertion`.\n\nBy default, this method calls \
-             [`TsConstAssertion::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsConstAssertion::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
-        <TsConstAssertion as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_const_assertion(
+        &mut self,
+        node: &mut TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsConstAssertion as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstructSignatureDecl`.\n\nBy default, this method calls \
-             [`TsConstructSignatureDecl::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsConstructSignatureDecl::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_ts_construct_signature_decl(
+    fn visit_mut_ts_construct_signature_decl(
         &mut self,
-        node: TsConstructSignatureDecl,
-    ) -> TsConstructSignatureDecl {
-        <TsConstructSignatureDecl as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsConstructSignatureDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstructorType`.\n\nBy default, this method calls \
-             [`TsConstructorType::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsConstructorType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
-        <TsConstructorType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_constructor_type(
+        &mut self,
+        node: &mut TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsConstructorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEntityName`.\n\nBy default, this method calls \
-             [`TsEntityName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsEntityName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
-        <TsEntityName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
+        <TsEntityName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEnumDecl`.\n\nBy default, this method calls \
-             [`TsEnumDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsEnumDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
-        <TsEnumDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
+        <TsEnumDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEnumMember`.\n\nBy default, this method calls \
-             [`TsEnumMember::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsEnumMember::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
-        <TsEnumMember as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
+        <TsEnumMember as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEnumMemberId`.\n\nBy default, this method calls \
-             [`TsEnumMemberId::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsEnumMemberId::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
-        <TsEnumMemberId as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_enum_member_id(
+        &mut self,
+        node: &mut TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsEnumMemberId as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsEnumMember >`.\n\nBy default, this method calls [`Vec < \
-             TsEnumMember >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             TsEnumMember >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
-        <Vec<TsEnumMember> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_enum_members(
+        &mut self,
+        node: &mut Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<TsEnumMember> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExportAssignment`.\n\nBy default, this method calls \
-             [`TsExportAssignment::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsExportAssignment::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
-        <TsExportAssignment as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_export_assignment(
+        &mut self,
+        node: &mut TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsExportAssignment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExprWithTypeArgs`.\n\nBy default, this method calls \
-             [`TsExprWithTypeArgs::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsExprWithTypeArgs::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
-        <TsExprWithTypeArgs as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_expr_with_type_args(
+        &mut self,
+        node: &mut TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsExprWithTypeArgs as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsExprWithTypeArgs >`.\n\nBy default, this method calls \
-             [`Vec < TsExprWithTypeArgs >::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`Vec < TsExprWithTypeArgs >::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_ts_expr_with_type_argss(
+    fn visit_mut_ts_expr_with_type_argss(
         &mut self,
-        node: Vec<TsExprWithTypeArgs>,
-    ) -> Vec<TsExprWithTypeArgs> {
-        <Vec<TsExprWithTypeArgs> as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<TsExprWithTypeArgs> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExternalModuleRef`.\n\nBy default, this method calls \
-             [`TsExternalModuleRef::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsExternalModuleRef::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
-        <TsExternalModuleRef as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_external_module_ref(
+        &mut self,
+        node: &mut TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsExternalModuleRef as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnOrConstructorType`.\n\nBy default, this method calls \
-             [`TsFnOrConstructorType::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsFnOrConstructorType::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_ts_fn_or_constructor_type(
+    fn visit_mut_ts_fn_or_constructor_type(
         &mut self,
-        node: TsFnOrConstructorType,
-    ) -> TsFnOrConstructorType {
-        <TsFnOrConstructorType as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsFnOrConstructorType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnParam`.\n\nBy default, this method calls \
-             [`TsFnParam::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsFnParam::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
-        <TsFnParam as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
+        <TsFnParam as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsFnParam >`.\n\nBy default, this method calls [`Vec < \
-             TsFnParam >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             TsFnParam >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
-        <Vec<TsFnParam> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
+        <Vec<TsFnParam> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnType`.\n\nBy default, this method calls \
-             [`TsFnType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsFnType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
-        <TsFnType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
+        <TsFnType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsGetterSignature`.\n\nBy default, this method calls \
-             [`TsGetterSignature::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsGetterSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
-        <TsGetterSignature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_getter_signature(
+        &mut self,
+        node: &mut TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsGetterSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsImportEqualsDecl`.\n\nBy default, this method calls \
-             [`TsImportEqualsDecl::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsImportEqualsDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
-        <TsImportEqualsDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_import_equals_decl(
+        &mut self,
+        node: &mut TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsImportEqualsDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsImportType`.\n\nBy default, this method calls \
-             [`TsImportType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsImportType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
-        <TsImportType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
+        <TsImportType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIndexSignature`.\n\nBy default, this method calls \
-             [`TsIndexSignature::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsIndexSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
-        <TsIndexSignature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_index_signature(
+        &mut self,
+        node: &mut TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsIndexSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIndexedAccessType`.\n\nBy default, this method calls \
-             [`TsIndexedAccessType::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsIndexedAccessType::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
-        <TsIndexedAccessType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_indexed_access_type(
+        &mut self,
+        node: &mut TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsIndexedAccessType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInferType`.\n\nBy default, this method calls \
-             [`TsInferType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsInferType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
-        <TsInferType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
+        <TsInferType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInstantiation`.\n\nBy default, this method calls \
-             [`TsInstantiation::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsInstantiation::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
-        <TsInstantiation as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_instantiation(
+        &mut self,
+        node: &mut TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsInstantiation as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInterfaceBody`.\n\nBy default, this method calls \
-             [`TsInterfaceBody::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsInterfaceBody::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
-        <TsInterfaceBody as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_interface_body(
+        &mut self,
+        node: &mut TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsInterfaceBody as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInterfaceDecl`.\n\nBy default, this method calls \
-             [`TsInterfaceDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsInterfaceDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
-        <TsInterfaceDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_interface_decl(
+        &mut self,
+        node: &mut TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsInterfaceDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIntersectionType`.\n\nBy default, this method calls \
-             [`TsIntersectionType::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsIntersectionType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
-        <TsIntersectionType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_intersection_type(
+        &mut self,
+        node: &mut TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsIntersectionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsKeywordType`.\n\nBy default, this method calls \
-             [`TsKeywordType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsKeywordType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
-        <TsKeywordType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_keyword_type(
+        &mut self,
+        node: &mut TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsKeywordType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsKeywordTypeKind`.\n\nBy default, this method calls \
-             [`TsKeywordTypeKind::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsKeywordTypeKind::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
-        <TsKeywordTypeKind as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_keyword_type_kind(
+        &mut self,
+        node: &mut TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsKeywordTypeKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsLit`.\n\nBy default, this method calls \
-             [`TsLit::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`TsLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
-        <TsLit as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
+        <TsLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsLitType`.\n\nBy default, this method calls \
-             [`TsLitType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsLitType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
-        <TsLitType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
+        <TsLitType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsMappedType`.\n\nBy default, this method calls \
-             [`TsMappedType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsMappedType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
-        <TsMappedType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
+        <TsMappedType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsMethodSignature`.\n\nBy default, this method calls \
-             [`TsMethodSignature::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsMethodSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
-        <TsMethodSignature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_method_signature(
+        &mut self,
+        node: &mut TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsMethodSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleBlock`.\n\nBy default, this method calls \
-             [`TsModuleBlock::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsModuleBlock::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
-        <TsModuleBlock as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_module_block(
+        &mut self,
+        node: &mut TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsModuleBlock as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleDecl`.\n\nBy default, this method calls \
-             [`TsModuleDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsModuleDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
-        <TsModuleDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
+        <TsModuleDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleName`.\n\nBy default, this method calls \
-             [`TsModuleName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsModuleName::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
-        <TsModuleName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
+        <TsModuleName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleRef`.\n\nBy default, this method calls \
-             [`TsModuleRef::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsModuleRef::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
-        <TsModuleRef as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
+        <TsModuleRef as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceBody`.\n\nBy default, this method calls \
-             [`TsNamespaceBody::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsNamespaceBody::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
-        <TsNamespaceBody as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_namespace_body(
+        &mut self,
+        node: &mut TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsNamespaceBody as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsNamespaceDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
-        <TsNamespaceDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_namespace_decl(
+        &mut self,
+        node: &mut TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsNamespaceDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceExportDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceExportDecl::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsNamespaceExportDecl::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_ts_namespace_export_decl(
+    fn visit_mut_ts_namespace_export_decl(
         &mut self,
-        node: TsNamespaceExportDecl,
-    ) -> TsNamespaceExportDecl {
-        <TsNamespaceExportDecl as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsNamespaceExportDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNonNullExpr`.\n\nBy default, this method calls \
-             [`TsNonNullExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsNonNullExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
-        <TsNonNullExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_non_null_expr(
+        &mut self,
+        node: &mut TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsNonNullExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsOptionalType`.\n\nBy default, this method calls \
-             [`TsOptionalType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsOptionalType::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
-        <TsOptionalType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_optional_type(
+        &mut self,
+        node: &mut TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsOptionalType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParamProp`.\n\nBy default, this method calls \
-             [`TsParamProp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsParamProp::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
-        <TsParamProp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
+        <TsParamProp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParamPropParam`.\n\nBy default, this method calls \
-             [`TsParamPropParam::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsParamPropParam::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
-        <TsParamPropParam as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_param_prop_param(
+        &mut self,
+        node: &mut TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsParamPropParam as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParenthesizedType`.\n\nBy default, this method calls \
-             [`TsParenthesizedType::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsParenthesizedType::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
-        <TsParenthesizedType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_parenthesized_type(
+        &mut self,
+        node: &mut TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsParenthesizedType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsPropertySignature`.\n\nBy default, this method calls \
-             [`TsPropertySignature::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsPropertySignature::visit_mut_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
-        <TsPropertySignature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_property_signature(
+        &mut self,
+        node: &mut TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsPropertySignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsQualifiedName`.\n\nBy default, this method calls \
-             [`TsQualifiedName::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsQualifiedName::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
-        <TsQualifiedName as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_qualified_name(
+        &mut self,
+        node: &mut TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsQualifiedName as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsRestType`.\n\nBy default, this method calls \
-             [`TsRestType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsRestType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
-        <TsRestType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
+        <TsRestType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsSatisfiesExpr`.\n\nBy default, this method calls \
-             [`TsSatisfiesExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsSatisfiesExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
-        <TsSatisfiesExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_satisfies_expr(
+        &mut self,
+        node: &mut TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsSatisfiesExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsSetterSignature`.\n\nBy default, this method calls \
-             [`TsSetterSignature::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsSetterSignature::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
-        <TsSetterSignature as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_setter_signature(
+        &mut self,
+        node: &mut TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsSetterSignature as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsThisType`.\n\nBy default, this method calls \
-             [`TsThisType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsThisType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
-        <TsThisType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
+        <TsThisType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsThisTypeOrIdent`.\n\nBy default, this method calls \
-             [`TsThisTypeOrIdent::fold_children_with`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsThisTypeOrIdent::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
-        <TsThisTypeOrIdent as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_this_type_or_ident(
+        &mut self,
+        node: &mut TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsThisTypeOrIdent as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTplLitType`.\n\nBy default, this method calls \
-             [`TsTplLitType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTplLitType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
-        <TsTplLitType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
+        <TsTplLitType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTupleElement`.\n\nBy default, this method calls \
-             [`TsTupleElement::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTupleElement::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
-        <TsTupleElement as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_tuple_element(
+        &mut self,
+        node: &mut TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTupleElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTupleElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTupleElement >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < TsTupleElement >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
-        <Vec<TsTupleElement> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_tuple_elements(
+        &mut self,
+        node: &mut Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<TsTupleElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTupleType`.\n\nBy default, this method calls \
-             [`TsTupleType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTupleType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
-        <TsTupleType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
+        <TsTupleType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsType`.\n\nBy default, this method calls \
-             [`TsType::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`TsType::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType) -> TsType {
-        <TsType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
+        <TsType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeAliasDecl`.\n\nBy default, this method calls \
-             [`TsTypeAliasDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeAliasDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
-        <TsTypeAliasDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_alias_decl(
+        &mut self,
+        node: &mut TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeAliasDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeAnn`.\n\nBy default, this method calls \
-             [`TsTypeAnn::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeAnn::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
-        <TsTypeAnn as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
+        <TsTypeAnn as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeAssertion`.\n\nBy default, this method calls \
-             [`TsTypeAssertion::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeAssertion::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
-        <TsTypeAssertion as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_assertion(
+        &mut self,
+        node: &mut TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeAssertion as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeElement`.\n\nBy default, this method calls \
-             [`TsTypeElement::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeElement::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
-        <TsTypeElement as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_element(
+        &mut self,
+        node: &mut TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeElement as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTypeElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTypeElement >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < TsTypeElement >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
-        <Vec<TsTypeElement> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_elements(
+        &mut self,
+        node: &mut Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<TsTypeElement> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeLit`.\n\nBy default, this method calls \
-             [`TsTypeLit::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeLit::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
-        <TsTypeLit as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
+        <TsTypeLit as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeOperator`.\n\nBy default, this method calls \
-             [`TsTypeOperator::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeOperator::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
-        <TsTypeOperator as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_operator(
+        &mut self,
+        node: &mut TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeOperator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeOperatorOp`.\n\nBy default, this method calls \
-             [`TsTypeOperatorOp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeOperatorOp::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
-        <TsTypeOperatorOp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_operator_op(
+        &mut self,
+        node: &mut TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeOperatorOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParam`.\n\nBy default, this method calls \
-             [`TsTypeParam::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeParam::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
-        <TsTypeParam as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
+        <TsTypeParam as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParamDecl`.\n\nBy default, this method calls \
-             [`TsTypeParamDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeParamDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
-        <TsTypeParamDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_param_decl(
+        &mut self,
+        node: &mut TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeParamDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParamInstantiation`.\n\nBy default, this method calls \
-             [`TsTypeParamInstantiation::fold_children_with`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeParamInstantiation::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_ts_type_param_instantiation(
+    fn visit_mut_ts_type_param_instantiation(
         &mut self,
-        node: TsTypeParamInstantiation,
-    ) -> TsTypeParamInstantiation {
-        <TsTypeParamInstantiation as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeParamInstantiation as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTypeParam >`.\n\nBy default, this method calls [`Vec < \
-             TsTypeParam >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             TsTypeParam >::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
-        <Vec<TsTypeParam> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_params(
+        &mut self,
+        node: &mut Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<TsTypeParam> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypePredicate`.\n\nBy default, this method calls \
-             [`TsTypePredicate::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypePredicate::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
-        <TsTypePredicate as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_predicate(
+        &mut self,
+        node: &mut TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypePredicate as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeQuery`.\n\nBy default, this method calls \
-             [`TsTypeQuery::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeQuery::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
-        <TsTypeQuery as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
+        <TsTypeQuery as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeQueryExpr`.\n\nBy default, this method calls \
-             [`TsTypeQueryExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeQueryExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
-        <TsTypeQueryExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_query_expr(
+        &mut self,
+        node: &mut TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsTypeQueryExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeRef`.\n\nBy default, this method calls \
-             [`TsTypeRef::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsTypeRef::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
-        <TsTypeRef as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
+        <TsTypeRef as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Box < TsType > >`.\n\nBy default, this method calls [`Vec \
-             < Box < TsType > >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < Box < TsType > >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
-        <Vec<Box<TsType>> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
+        <Vec<Box<TsType>> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsUnionOrIntersectionType`.\n\nBy default, this method calls \
-             [`TsUnionOrIntersectionType::fold_children_with`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsUnionOrIntersectionType::visit_mut_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn fold_ts_union_or_intersection_type(
+    fn visit_mut_ts_union_or_intersection_type(
         &mut self,
-        node: TsUnionOrIntersectionType,
-    ) -> TsUnionOrIntersectionType {
-        <TsUnionOrIntersectionType as FoldWith<Self>>::fold_children_with(node, self)
+        node: &mut TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <TsUnionOrIntersectionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsUnionType`.\n\nBy default, this method calls \
-             [`TsUnionType::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsUnionType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
-        <TsUnionType as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
+        <TsUnionType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UnaryExpr`.\n\nBy default, this method calls \
-             [`UnaryExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UnaryExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
-        <UnaryExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
+        <UnaryExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UnaryOp`.\n\nBy default, this method calls \
-             [`UnaryOp::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`UnaryOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
-        <UnaryOp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
+        <UnaryOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UpdateExpr`.\n\nBy default, this method calls \
-             [`UpdateExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UpdateExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
-        <UpdateExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
+        <UpdateExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UpdateOp`.\n\nBy default, this method calls \
-             [`UpdateOp::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UpdateOp::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
-        <UpdateOp as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
+        <UpdateOp as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `UsingDecl`.\n\nBy default, this method calls \
-             [`UsingDecl::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UsingDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
-        <UsingDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
+        <UsingDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `VarDecl`.\n\nBy default, this method calls \
-             [`VarDecl::fold_children_with`]. If you want to recurse, you need to call it manually."]
+             [`VarDecl::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
-        <VarDecl as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
+        <VarDecl as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `VarDeclKind`.\n\nBy default, this method calls \
-             [`VarDeclKind::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`VarDeclKind::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
-        <VarDeclKind as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
+        <VarDeclKind as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `VarDeclOrExpr`.\n\nBy default, this method calls \
-             [`VarDeclOrExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`VarDeclOrExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
-        <VarDeclOrExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_var_decl_or_expr(
+        &mut self,
+        node: &mut VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <VarDeclOrExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `VarDeclarator`.\n\nBy default, this method calls \
-             [`VarDeclarator::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`VarDeclarator::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
-        <VarDeclarator as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
+        <VarDeclarator as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < VarDeclarator >`.\n\nBy default, this method calls [`Vec \
-             < VarDeclarator >::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             < VarDeclarator >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
-        <Vec<VarDeclarator> as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_var_declarators(
+        &mut self,
+        node: &mut Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <Vec<VarDeclarator> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `WhileStmt`.\n\nBy default, this method calls \
-             [`WhileStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`WhileStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
-        <WhileStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
+        <WhileStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `WithStmt`.\n\nBy default, this method calls \
-             [`WithStmt::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`WithStmt::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
-        <WithStmt as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
+        <WithStmt as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `YieldExpr`.\n\nBy default, this method calls \
-             [`YieldExpr::fold_children_with`]. If you want to recurse, you need to call it \
-             manually."]
+             [`YieldExpr::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
-        <YieldExpr as FoldWith<Self>>::fold_children_with(node, self)
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
+        <YieldExpr as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
 }
-impl<V> Fold for &mut V
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitMutAstPath for &mut V
 where
-    V: ?Sized + Fold,
+    V: ?Sized + VisitMutAstPath,
 {
     #[inline]
-    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
-        <V as Fold>::fold_accessibility(&mut **self, node)
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
-        <V as Fold>::fold_array_lit(&mut **self, node)
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_array_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
-        <V as Fold>::fold_array_pat(&mut **self, node)
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_array_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
-        <V as Fold>::fold_arrow_expr(&mut **self, node)
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_arrow_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
-        <V as Fold>::fold_assign_expr(&mut **self, node)
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
-        <V as Fold>::fold_assign_op(&mut **self, node)
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
-        <V as Fold>::fold_assign_pat(&mut **self, node)
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
-        <V as Fold>::fold_assign_pat_prop(&mut **self, node)
+    fn visit_mut_assign_pat_prop(
+        &mut self,
+        node: &mut AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_assign_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
-        <V as Fold>::fold_assign_prop(&mut **self, node)
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
-        <V as Fold>::fold_assign_target(&mut **self, node)
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
-        <V as Fold>::fold_assign_target_pat(&mut **self, node)
+    fn visit_mut_assign_target_pat(
+        &mut self,
+        node: &mut AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_assign_target_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
-        <V as Fold>::fold_atom(&mut **self, node)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
-        <V as Fold>::fold_auto_accessor(&mut **self, node)
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_auto_accessor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
-        <V as Fold>::fold_await_expr(&mut **self, node)
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_await_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
-        <V as Fold>::fold_big_int(&mut **self, node)
+    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_big_int(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
-        <V as Fold>::fold_big_int_value(&mut **self, node)
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_big_int_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
-        <V as Fold>::fold_bin_expr(&mut **self, node)
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bin_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
-        <V as Fold>::fold_binary_op(&mut **self, node)
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_binary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
-        <V as Fold>::fold_binding_ident(&mut **self, node)
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_binding_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
-        <V as Fold>::fold_block_stmt(&mut **self, node)
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
-        <V as Fold>::fold_block_stmt_or_expr(&mut **self, node)
+    fn visit_mut_block_stmt_or_expr(
+        &mut self,
+        node: &mut BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool) -> Bool {
-        <V as Fold>::fold_bool(&mut **self, node)
+    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bool(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
-        <V as Fold>::fold_break_stmt(&mut **self, node)
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_break_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
-        <V as Fold>::fold_call_expr(&mut **self, node)
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_call_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee) -> Callee {
-        <V as Fold>::fold_callee(&mut **self, node)
+    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_callee(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
-        <V as Fold>::fold_catch_clause(&mut **self, node)
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class) -> Class {
-        <V as Fold>::fold_class(&mut **self, node)
+    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
-        <V as Fold>::fold_class_decl(&mut **self, node)
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
-        <V as Fold>::fold_class_expr(&mut **self, node)
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
-        <V as Fold>::fold_class_member(&mut **self, node)
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
-        <V as Fold>::fold_class_members(&mut **self, node)
+    fn visit_mut_class_members(
+        &mut self,
+        node: &mut Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_class_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
-        <V as Fold>::fold_class_method(&mut **self, node)
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
-        <V as Fold>::fold_class_prop(&mut **self, node)
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
-        <V as Fold>::fold_computed_prop_name(&mut **self, node)
+    fn visit_mut_computed_prop_name(
+        &mut self,
+        node: &mut ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_computed_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
-        <V as Fold>::fold_cond_expr(&mut **self, node)
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_cond_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
-        <V as Fold>::fold_constructor(&mut **self, node)
+    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_constructor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
-        <V as Fold>::fold_continue_stmt(&mut **self, node)
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_continue_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
-        <V as Fold>::fold_debugger_stmt(&mut **self, node)
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_debugger_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl) -> Decl {
-        <V as Fold>::fold_decl(&mut **self, node)
+    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
-        <V as Fold>::fold_decorator(&mut **self, node)
+    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decorator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
-        <V as Fold>::fold_decorators(&mut **self, node)
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decorators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
-        <V as Fold>::fold_default_decl(&mut **self, node)
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
-        <V as Fold>::fold_do_while_stmt(&mut **self, node)
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_do_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
-        <V as Fold>::fold_empty_stmt(&mut **self, node)
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_empty_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
-        <V as Fold>::fold_es_version(&mut **self, node)
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_es_version(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
-        <V as Fold>::fold_export_all(&mut **self, node)
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_all(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
-        <V as Fold>::fold_export_decl(&mut **self, node)
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
-        <V as Fold>::fold_export_default_decl(&mut **self, node)
+    fn visit_mut_export_default_decl(
+        &mut self,
+        node: &mut ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
-        <V as Fold>::fold_export_default_expr(&mut **self, node)
+    fn visit_mut_export_default_expr(
+        &mut self,
+        node: &mut ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_default_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_default_specifier(
+    fn visit_mut_export_default_specifier(
         &mut self,
-        node: ExportDefaultSpecifier,
-    ) -> ExportDefaultSpecifier {
-        <V as Fold>::fold_export_default_specifier(&mut **self, node)
+        node: &mut ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
-        <V as Fold>::fold_export_named_specifier(&mut **self, node)
+    fn visit_mut_export_named_specifier(
+        &mut self,
+        node: &mut ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_namespace_specifier(
+    fn visit_mut_export_namespace_specifier(
         &mut self,
-        node: ExportNamespaceSpecifier,
-    ) -> ExportNamespaceSpecifier {
-        <V as Fold>::fold_export_namespace_specifier(&mut **self, node)
+        node: &mut ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
-        <V as Fold>::fold_export_specifier(&mut **self, node)
+    fn visit_mut_export_specifier(
+        &mut self,
+        node: &mut ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
-        <V as Fold>::fold_export_specifiers(&mut **self, node)
+    fn visit_mut_export_specifiers(
+        &mut self,
+        node: &mut Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr) -> Expr {
-        <V as Fold>::fold_expr(&mut **self, node)
+    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
-        <V as Fold>::fold_expr_or_spread(&mut **self, node)
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
-        <V as Fold>::fold_expr_or_spreads(&mut **self, node)
+    fn visit_mut_expr_or_spreads(
+        &mut self,
+        node: &mut Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
-        <V as Fold>::fold_expr_stmt(&mut **self, node)
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
-        <V as Fold>::fold_exprs(&mut **self, node)
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_exprs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
-        <V as Fold>::fold_fn_decl(&mut **self, node)
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_fn_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
-        <V as Fold>::fold_fn_expr(&mut **self, node)
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_fn_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
-        <V as Fold>::fold_for_head(&mut **self, node)
+    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_head(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
-        <V as Fold>::fold_for_in_stmt(&mut **self, node)
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_in_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
-        <V as Fold>::fold_for_of_stmt(&mut **self, node)
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_of_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
-        <V as Fold>::fold_for_stmt(&mut **self, node)
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
-        <V as Fold>::fold_function(&mut **self, node)
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
-        <V as Fold>::fold_getter_prop(&mut **self, node)
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_getter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
-        <V as Fold>::fold_ident(&mut **self, node)
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
-        <V as Fold>::fold_ident_name(&mut **self, node)
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
-        <V as Fold>::fold_if_stmt(&mut **self, node)
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_if_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import) -> Import {
-        <V as Fold>::fold_import(&mut **self, node)
+    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
-        <V as Fold>::fold_import_decl(&mut **self, node)
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_default_specifier(
+    fn visit_mut_import_default_specifier(
         &mut self,
-        node: ImportDefaultSpecifier,
-    ) -> ImportDefaultSpecifier {
-        <V as Fold>::fold_import_default_specifier(&mut **self, node)
+        node: &mut ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
-        <V as Fold>::fold_import_named_specifier(&mut **self, node)
+    fn visit_mut_import_named_specifier(
+        &mut self,
+        node: &mut ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
-        <V as Fold>::fold_import_phase(&mut **self, node)
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_phase(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
-        <V as Fold>::fold_import_specifier(&mut **self, node)
+    fn visit_mut_import_specifier(
+        &mut self,
+        node: &mut ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
-        <V as Fold>::fold_import_specifiers(&mut **self, node)
+    fn visit_mut_import_specifiers(
+        &mut self,
+        node: &mut Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_star_as_specifier(
+    fn visit_mut_import_star_as_specifier(
         &mut self,
-        node: ImportStarAsSpecifier,
-    ) -> ImportStarAsSpecifier {
-        <V as Fold>::fold_import_star_as_specifier(&mut **self, node)
+        node: &mut ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
-        <V as Fold>::fold_import_with(&mut **self, node)
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_with(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
-        <V as Fold>::fold_import_with_item(&mut **self, node)
+    fn visit_mut_import_with_item(
+        &mut self,
+        node: &mut ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_with_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
-        <V as Fold>::fold_import_with_items(&mut **self, node)
+    fn visit_mut_import_with_items(
+        &mut self,
+        node: &mut Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_with_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
-        <V as Fold>::fold_invalid(&mut **self, node)
+    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_invalid(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
-        <V as Fold>::fold_jsx_attr(&mut **self, node)
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
-        <V as Fold>::fold_jsx_attr_name(&mut **self, node)
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
-        <V as Fold>::fold_jsx_attr_or_spread(&mut **self, node)
+    fn visit_mut_jsx_attr_or_spread(
+        &mut self,
+        node: &mut JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
-        <V as Fold>::fold_jsx_attr_or_spreads(&mut **self, node)
+    fn visit_mut_jsx_attr_or_spreads(
+        &mut self,
+        node: &mut Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
-        <V as Fold>::fold_jsx_attr_value(&mut **self, node)
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
-        <V as Fold>::fold_jsx_closing_element(&mut **self, node)
+    fn visit_mut_jsx_closing_element(
+        &mut self,
+        node: &mut JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
-        <V as Fold>::fold_jsx_closing_fragment(&mut **self, node)
+    fn visit_mut_jsx_closing_fragment(
+        &mut self,
+        node: &mut JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
-        <V as Fold>::fold_jsx_element(&mut **self, node)
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
-        <V as Fold>::fold_jsx_element_child(&mut **self, node)
+    fn visit_mut_jsx_element_child(
+        &mut self,
+        node: &mut JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
-        <V as Fold>::fold_jsx_element_childs(&mut **self, node)
+    fn visit_mut_jsx_element_childs(
+        &mut self,
+        node: &mut Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_childs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
-        <V as Fold>::fold_jsx_element_name(&mut **self, node)
+    fn visit_mut_jsx_element_name(
+        &mut self,
+        node: &mut JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
-        <V as Fold>::fold_jsx_empty_expr(&mut **self, node)
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
-        <V as Fold>::fold_jsx_expr(&mut **self, node)
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
-        <V as Fold>::fold_jsx_expr_container(&mut **self, node)
+    fn visit_mut_jsx_expr_container(
+        &mut self,
+        node: &mut JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_expr_container(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
-        <V as Fold>::fold_jsx_fragment(&mut **self, node)
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
-        <V as Fold>::fold_jsx_member_expr(&mut **self, node)
+    fn visit_mut_jsx_member_expr(
+        &mut self,
+        node: &mut JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
-        <V as Fold>::fold_jsx_namespaced_name(&mut **self, node)
+    fn visit_mut_jsx_namespaced_name(
+        &mut self,
+        node: &mut JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
-        <V as Fold>::fold_jsx_object(&mut **self, node)
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_object(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
-        <V as Fold>::fold_jsx_opening_element(&mut **self, node)
+    fn visit_mut_jsx_opening_element(
+        &mut self,
+        node: &mut JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_opening_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
-        <V as Fold>::fold_jsx_opening_fragment(&mut **self, node)
+    fn visit_mut_jsx_opening_fragment(
+        &mut self,
+        node: &mut JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
-        <V as Fold>::fold_jsx_spread_child(&mut **self, node)
+    fn visit_mut_jsx_spread_child(
+        &mut self,
+        node: &mut JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_spread_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
-        <V as Fold>::fold_jsx_text(&mut **self, node)
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_text(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key) -> Key {
-        <V as Fold>::fold_key(&mut **self, node)
+    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_key(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
-        <V as Fold>::fold_key_value_pat_prop(&mut **self, node)
+    fn visit_mut_key_value_pat_prop(
+        &mut self,
+        node: &mut KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
-        <V as Fold>::fold_key_value_prop(&mut **self, node)
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_key_value_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
-        <V as Fold>::fold_labeled_stmt(&mut **self, node)
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_labeled_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit) -> Lit {
-        <V as Fold>::fold_lit(&mut **self, node)
+    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
-        <V as Fold>::fold_member_expr(&mut **self, node)
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
-        <V as Fold>::fold_member_prop(&mut **self, node)
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_member_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
-        <V as Fold>::fold_meta_prop_expr(&mut **self, node)
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_meta_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
-        <V as Fold>::fold_meta_prop_kind(&mut **self, node)
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_meta_prop_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
-        <V as Fold>::fold_method_kind(&mut **self, node)
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_method_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
-        <V as Fold>::fold_method_prop(&mut **self, node)
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_method_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module) -> Module {
-        <V as Fold>::fold_module(&mut **self, node)
+    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
-        <V as Fold>::fold_module_decl(&mut **self, node)
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
-        <V as Fold>::fold_module_export_name(&mut **self, node)
+    fn visit_mut_module_export_name(
+        &mut self,
+        node: &mut ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
-        <V as Fold>::fold_module_item(&mut **self, node)
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
-        <V as Fold>::fold_module_items(&mut **self, node)
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
-        <V as Fold>::fold_named_export(&mut **self, node)
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_named_export(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
-        <V as Fold>::fold_new_expr(&mut **self, node)
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_new_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null) -> Null {
-        <V as Fold>::fold_null(&mut **self, node)
+    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_null(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
-        <V as Fold>::fold_number(&mut **self, node)
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
-        <V as Fold>::fold_object_lit(&mut **self, node)
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
-        <V as Fold>::fold_object_pat(&mut **self, node)
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
-        <V as Fold>::fold_object_pat_prop(&mut **self, node)
+    fn visit_mut_object_pat_prop(
+        &mut self,
+        node: &mut ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_object_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
-        <V as Fold>::fold_object_pat_props(&mut **self, node)
+    fn visit_mut_object_pat_props(
+        &mut self,
+        node: &mut Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_object_pat_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
-        <V as Fold>::fold_opt_accessibility(&mut **self, node)
+    fn visit_mut_opt_accessibility(
+        &mut self,
+        node: &mut Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
-        <V as Fold>::fold_opt_atom(&mut **self, node)
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
-        <V as Fold>::fold_opt_block_stmt(&mut **self, node)
+    fn visit_mut_opt_block_stmt(
+        &mut self,
+        node: &mut Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
-        <V as Fold>::fold_opt_call(&mut **self, node)
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_call(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
-        <V as Fold>::fold_opt_catch_clause(&mut **self, node)
+    fn visit_mut_opt_catch_clause(
+        &mut self,
+        node: &mut Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
-        <V as Fold>::fold_opt_chain_base(&mut **self, node)
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_chain_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
-        <V as Fold>::fold_opt_chain_expr(&mut **self, node)
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_chain_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
-        <V as Fold>::fold_opt_expr(&mut **self, node)
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
-        <V as Fold>::fold_opt_expr_or_spread(&mut **self, node)
+    fn visit_mut_opt_expr_or_spread(
+        &mut self,
+        node: &mut Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_expr_or_spreads(
+    fn visit_mut_opt_expr_or_spreads(
         &mut self,
-        node: Option<Vec<ExprOrSpread>>,
-    ) -> Option<Vec<ExprOrSpread>> {
-        <V as Fold>::fold_opt_expr_or_spreads(&mut **self, node)
+        node: &mut Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
-        <V as Fold>::fold_opt_ident(&mut **self, node)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
-        <V as Fold>::fold_opt_jsx_attr_value(&mut **self, node)
+    fn visit_mut_opt_jsx_attr_value(
+        &mut self,
+        node: &mut Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_jsx_closing_element(
+    fn visit_mut_opt_jsx_closing_element(
         &mut self,
-        node: Option<JSXClosingElement>,
-    ) -> Option<JSXClosingElement> {
-        <V as Fold>::fold_opt_jsx_closing_element(&mut **self, node)
+        node: &mut Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_module_export_name(
+    fn visit_mut_opt_module_export_name(
         &mut self,
-        node: Option<ModuleExportName>,
-    ) -> Option<ModuleExportName> {
-        <V as Fold>::fold_opt_module_export_name(&mut **self, node)
+        node: &mut Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
-        <V as Fold>::fold_opt_object_lit(&mut **self, node)
+    fn visit_mut_opt_object_lit(
+        &mut self,
+        node: &mut Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
-        <V as Fold>::fold_opt_pat(&mut **self, node)
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
-        <V as Fold>::fold_opt_span(&mut **self, node)
+    fn visit_mut_opt_span(
+        &mut self,
+        node: &mut Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
-        <V as Fold>::fold_opt_stmt(&mut **self, node)
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
-        <V as Fold>::fold_opt_str(&mut **self, node)
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
-        <V as Fold>::fold_opt_true_plus_minus(&mut **self, node)
+    fn visit_mut_opt_true_plus_minus(
+        &mut self,
+        node: &mut Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
-        <V as Fold>::fold_opt_ts_entity_name(&mut **self, node)
+    fn visit_mut_opt_ts_entity_name(
+        &mut self,
+        node: &mut Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_namespace_body(
+    fn visit_mut_opt_ts_namespace_body(
         &mut self,
-        node: Option<TsNamespaceBody>,
-    ) -> Option<TsNamespaceBody> {
-        <V as Fold>::fold_opt_ts_namespace_body(&mut **self, node)
+        node: &mut Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
-        <V as Fold>::fold_opt_ts_type(&mut **self, node)
+    fn visit_mut_opt_ts_type(
+        &mut self,
+        node: &mut Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
-        <V as Fold>::fold_opt_ts_type_ann(&mut **self, node)
+    fn visit_mut_opt_ts_type_ann(
+        &mut self,
+        node: &mut Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_decl(
+    fn visit_mut_opt_ts_type_param_decl(
         &mut self,
-        node: Option<Box<TsTypeParamDecl>>,
-    ) -> Option<Box<TsTypeParamDecl>> {
-        <V as Fold>::fold_opt_ts_type_param_decl(&mut **self, node)
+        node: &mut Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_instantiation(
+    fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
-        node: Option<Box<TsTypeParamInstantiation>>,
-    ) -> Option<Box<TsTypeParamInstantiation>> {
-        <V as Fold>::fold_opt_ts_type_param_instantiation(&mut **self, node)
+        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
-        <V as Fold>::fold_opt_var_decl_or_expr(&mut **self, node)
+    fn visit_mut_opt_var_decl_or_expr(
+        &mut self,
+        node: &mut Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_vec_expr_or_spreads(
+    fn visit_mut_opt_vec_expr_or_spreads(
         &mut self,
-        node: Vec<Option<ExprOrSpread>>,
-    ) -> Vec<Option<ExprOrSpread>> {
-        <V as Fold>::fold_opt_vec_expr_or_spreads(&mut **self, node)
+        node: &mut Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
-        <V as Fold>::fold_opt_vec_pats(&mut **self, node)
+    fn visit_mut_opt_vec_pats(
+        &mut self,
+        node: &mut Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_vec_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param) -> Param {
-        <V as Fold>::fold_param(&mut **self, node)
+    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
-        <V as Fold>::fold_param_or_ts_param_prop(&mut **self, node)
+    fn visit_mut_param_or_ts_param_prop(
+        &mut self,
+        node: &mut ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_param_or_ts_param_props(
+    fn visit_mut_param_or_ts_param_props(
         &mut self,
-        node: Vec<ParamOrTsParamProp>,
-    ) -> Vec<ParamOrTsParamProp> {
-        <V as Fold>::fold_param_or_ts_param_props(&mut **self, node)
+        node: &mut Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
-        <V as Fold>::fold_params(&mut **self, node)
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
-        <V as Fold>::fold_paren_expr(&mut **self, node)
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_paren_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat) -> Pat {
-        <V as Fold>::fold_pat(&mut **self, node)
+    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
-        <V as Fold>::fold_pats(&mut **self, node)
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
-        <V as Fold>::fold_private_method(&mut **self, node)
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
-        <V as Fold>::fold_private_name(&mut **self, node)
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
-        <V as Fold>::fold_private_prop(&mut **self, node)
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program) -> Program {
-        <V as Fold>::fold_program(&mut **self, node)
+    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_program(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop) -> Prop {
-        <V as Fold>::fold_prop(&mut **self, node)
+    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName) -> PropName {
-        <V as Fold>::fold_prop_name(&mut **self, node)
+    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
-        <V as Fold>::fold_prop_or_spread(&mut **self, node)
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
-        <V as Fold>::fold_prop_or_spreads(&mut **self, node)
+    fn visit_mut_prop_or_spreads(
+        &mut self,
+        node: &mut Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_prop_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex) -> Regex {
-        <V as Fold>::fold_regex(&mut **self, node)
+    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_regex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
-        <V as Fold>::fold_rest_pat(&mut **self, node)
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rest_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
-        <V as Fold>::fold_return_stmt(&mut **self, node)
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_return_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script) -> Script {
-        <V as Fold>::fold_script(&mut **self, node)
+    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_script(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
-        <V as Fold>::fold_seq_expr(&mut **self, node)
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_seq_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
-        <V as Fold>::fold_setter_prop(&mut **self, node)
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_setter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
-        <V as Fold>::fold_simple_assign_target(&mut **self, node)
+    fn visit_mut_simple_assign_target(
+        &mut self,
+        node: &mut SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_simple_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
-        <V as Fold>::fold_span(&mut **self, node)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
-        <V as Fold>::fold_spread_element(&mut **self, node)
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_spread_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
-        <V as Fold>::fold_static_block(&mut **self, node)
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_static_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
-        <V as Fold>::fold_stmt(&mut **self, node)
+    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
-        <V as Fold>::fold_stmts(&mut **self, node)
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stmts(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
-        <V as Fold>::fold_str(&mut **self, node)
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super) -> Super {
-        <V as Fold>::fold_super(&mut **self, node)
+    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_super(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
-        <V as Fold>::fold_super_prop(&mut **self, node)
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_super_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
-        <V as Fold>::fold_super_prop_expr(&mut **self, node)
+    fn visit_mut_super_prop_expr(
+        &mut self,
+        node: &mut SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_super_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
-        <V as Fold>::fold_switch_case(&mut **self, node)
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_case(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
-        <V as Fold>::fold_switch_cases(&mut **self, node)
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_cases(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
-        <V as Fold>::fold_switch_stmt(&mut **self, node)
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_syntax_context(
+    fn visit_mut_syntax_context(
         &mut self,
-        node: swc_common::SyntaxContext,
-    ) -> swc_common::SyntaxContext {
-        <V as Fold>::fold_syntax_context(&mut **self, node)
+        node: &mut swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_syntax_context(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
-        <V as Fold>::fold_tagged_tpl(&mut **self, node)
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tagged_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
-        <V as Fold>::fold_this_expr(&mut **self, node)
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_this_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
-        <V as Fold>::fold_throw_stmt(&mut **self, node)
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_throw_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
-        <V as Fold>::fold_tpl(&mut **self, node)
+    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
-        <V as Fold>::fold_tpl_element(&mut **self, node)
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
-        <V as Fold>::fold_tpl_elements(&mut **self, node)
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
-        <V as Fold>::fold_true_plus_minus(&mut **self, node)
+    fn visit_mut_true_plus_minus(
+        &mut self,
+        node: &mut TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
-        <V as Fold>::fold_try_stmt(&mut **self, node)
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_try_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
-        <V as Fold>::fold_ts_array_type(&mut **self, node)
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_array_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
-        <V as Fold>::fold_ts_as_expr(&mut **self, node)
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_as_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
-        <V as Fold>::fold_ts_call_signature_decl(&mut **self, node)
+    fn visit_mut_ts_call_signature_decl(
+        &mut self,
+        node: &mut TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
-        <V as Fold>::fold_ts_conditional_type(&mut **self, node)
+    fn visit_mut_ts_conditional_type(
+        &mut self,
+        node: &mut TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_conditional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
-        <V as Fold>::fold_ts_const_assertion(&mut **self, node)
+    fn visit_mut_ts_const_assertion(
+        &mut self,
+        node: &mut TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_const_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_construct_signature_decl(
+    fn visit_mut_ts_construct_signature_decl(
         &mut self,
-        node: TsConstructSignatureDecl,
-    ) -> TsConstructSignatureDecl {
-        <V as Fold>::fold_ts_construct_signature_decl(&mut **self, node)
+        node: &mut TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
-        <V as Fold>::fold_ts_constructor_type(&mut **self, node)
+    fn visit_mut_ts_constructor_type(
+        &mut self,
+        node: &mut TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
-        <V as Fold>::fold_ts_entity_name(&mut **self, node)
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
-        <V as Fold>::fold_ts_enum_decl(&mut **self, node)
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
-        <V as Fold>::fold_ts_enum_member(&mut **self, node)
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
-        <V as Fold>::fold_ts_enum_member_id(&mut **self, node)
+    fn visit_mut_ts_enum_member_id(
+        &mut self,
+        node: &mut TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
-        <V as Fold>::fold_ts_enum_members(&mut **self, node)
+    fn visit_mut_ts_enum_members(
+        &mut self,
+        node: &mut Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
-        <V as Fold>::fold_ts_export_assignment(&mut **self, node)
+    fn visit_mut_ts_export_assignment(
+        &mut self,
+        node: &mut TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_export_assignment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
-        <V as Fold>::fold_ts_expr_with_type_args(&mut **self, node)
+    fn visit_mut_ts_expr_with_type_args(
+        &mut self,
+        node: &mut TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_argss(
+    fn visit_mut_ts_expr_with_type_argss(
         &mut self,
-        node: Vec<TsExprWithTypeArgs>,
-    ) -> Vec<TsExprWithTypeArgs> {
-        <V as Fold>::fold_ts_expr_with_type_argss(&mut **self, node)
+        node: &mut Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
-        <V as Fold>::fold_ts_external_module_ref(&mut **self, node)
+    fn visit_mut_ts_external_module_ref(
+        &mut self,
+        node: &mut TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_or_constructor_type(
+    fn visit_mut_ts_fn_or_constructor_type(
         &mut self,
-        node: TsFnOrConstructorType,
-    ) -> TsFnOrConstructorType {
-        <V as Fold>::fold_ts_fn_or_constructor_type(&mut **self, node)
+        node: &mut TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
-        <V as Fold>::fold_ts_fn_param(&mut **self, node)
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
-        <V as Fold>::fold_ts_fn_params(&mut **self, node)
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
-        <V as Fold>::fold_ts_fn_type(&mut **self, node)
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
-        <V as Fold>::fold_ts_getter_signature(&mut **self, node)
+    fn visit_mut_ts_getter_signature(
+        &mut self,
+        node: &mut TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_getter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
-        <V as Fold>::fold_ts_import_equals_decl(&mut **self, node)
+    fn visit_mut_ts_import_equals_decl(
+        &mut self,
+        node: &mut TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
-        <V as Fold>::fold_ts_import_type(&mut **self, node)
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_import_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
-        <V as Fold>::fold_ts_index_signature(&mut **self, node)
+    fn visit_mut_ts_index_signature(
+        &mut self,
+        node: &mut TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_index_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
-        <V as Fold>::fold_ts_indexed_access_type(&mut **self, node)
+    fn visit_mut_ts_indexed_access_type(
+        &mut self,
+        node: &mut TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
-        <V as Fold>::fold_ts_infer_type(&mut **self, node)
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_infer_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
-        <V as Fold>::fold_ts_instantiation(&mut **self, node)
+    fn visit_mut_ts_instantiation(
+        &mut self,
+        node: &mut TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
-        <V as Fold>::fold_ts_interface_body(&mut **self, node)
+    fn visit_mut_ts_interface_body(
+        &mut self,
+        node: &mut TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_interface_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
-        <V as Fold>::fold_ts_interface_decl(&mut **self, node)
+    fn visit_mut_ts_interface_decl(
+        &mut self,
+        node: &mut TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_interface_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
-        <V as Fold>::fold_ts_intersection_type(&mut **self, node)
+    fn visit_mut_ts_intersection_type(
+        &mut self,
+        node: &mut TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
-        <V as Fold>::fold_ts_keyword_type(&mut **self, node)
+    fn visit_mut_ts_keyword_type(
+        &mut self,
+        node: &mut TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_keyword_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
-        <V as Fold>::fold_ts_keyword_type_kind(&mut **self, node)
+    fn visit_mut_ts_keyword_type_kind(
+        &mut self,
+        node: &mut TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
-        <V as Fold>::fold_ts_lit(&mut **self, node)
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
-        <V as Fold>::fold_ts_lit_type(&mut **self, node)
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
-        <V as Fold>::fold_ts_mapped_type(&mut **self, node)
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_mapped_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
-        <V as Fold>::fold_ts_method_signature(&mut **self, node)
+    fn visit_mut_ts_method_signature(
+        &mut self,
+        node: &mut TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_method_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
-        <V as Fold>::fold_ts_module_block(&mut **self, node)
+    fn visit_mut_ts_module_block(
+        &mut self,
+        node: &mut TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
-        <V as Fold>::fold_ts_module_decl(&mut **self, node)
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
-        <V as Fold>::fold_ts_module_name(&mut **self, node)
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
-        <V as Fold>::fold_ts_module_ref(&mut **self, node)
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
-        <V as Fold>::fold_ts_namespace_body(&mut **self, node)
+    fn visit_mut_ts_namespace_body(
+        &mut self,
+        node: &mut TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
-        <V as Fold>::fold_ts_namespace_decl(&mut **self, node)
+    fn visit_mut_ts_namespace_decl(
+        &mut self,
+        node: &mut TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_namespace_export_decl(
+    fn visit_mut_ts_namespace_export_decl(
         &mut self,
-        node: TsNamespaceExportDecl,
-    ) -> TsNamespaceExportDecl {
-        <V as Fold>::fold_ts_namespace_export_decl(&mut **self, node)
+        node: &mut TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
-        <V as Fold>::fold_ts_non_null_expr(&mut **self, node)
+    fn visit_mut_ts_non_null_expr(
+        &mut self,
+        node: &mut TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
-        <V as Fold>::fold_ts_optional_type(&mut **self, node)
+    fn visit_mut_ts_optional_type(
+        &mut self,
+        node: &mut TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_optional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
-        <V as Fold>::fold_ts_param_prop(&mut **self, node)
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
-        <V as Fold>::fold_ts_param_prop_param(&mut **self, node)
+    fn visit_mut_ts_param_prop_param(
+        &mut self,
+        node: &mut TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
-        <V as Fold>::fold_ts_parenthesized_type(&mut **self, node)
+    fn visit_mut_ts_parenthesized_type(
+        &mut self,
+        node: &mut TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
-        <V as Fold>::fold_ts_property_signature(&mut **self, node)
+    fn visit_mut_ts_property_signature(
+        &mut self,
+        node: &mut TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_property_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
-        <V as Fold>::fold_ts_qualified_name(&mut **self, node)
+    fn visit_mut_ts_qualified_name(
+        &mut self,
+        node: &mut TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_qualified_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
-        <V as Fold>::fold_ts_rest_type(&mut **self, node)
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_rest_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
-        <V as Fold>::fold_ts_satisfies_expr(&mut **self, node)
+    fn visit_mut_ts_satisfies_expr(
+        &mut self,
+        node: &mut TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
-        <V as Fold>::fold_ts_setter_signature(&mut **self, node)
+    fn visit_mut_ts_setter_signature(
+        &mut self,
+        node: &mut TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_setter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
-        <V as Fold>::fold_ts_this_type(&mut **self, node)
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_this_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
-        <V as Fold>::fold_ts_this_type_or_ident(&mut **self, node)
+    fn visit_mut_ts_this_type_or_ident(
+        &mut self,
+        node: &mut TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
-        <V as Fold>::fold_ts_tpl_lit_type(&mut **self, node)
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
-        <V as Fold>::fold_ts_tuple_element(&mut **self, node)
+    fn visit_mut_ts_tuple_element(
+        &mut self,
+        node: &mut TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
-        <V as Fold>::fold_ts_tuple_elements(&mut **self, node)
+    fn visit_mut_ts_tuple_elements(
+        &mut self,
+        node: &mut Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
-        <V as Fold>::fold_ts_tuple_type(&mut **self, node)
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType) -> TsType {
-        <V as Fold>::fold_ts_type(&mut **self, node)
+    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
-        <V as Fold>::fold_ts_type_alias_decl(&mut **self, node)
+    fn visit_mut_ts_type_alias_decl(
+        &mut self,
+        node: &mut TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
-        <V as Fold>::fold_ts_type_ann(&mut **self, node)
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
-        <V as Fold>::fold_ts_type_assertion(&mut **self, node)
+    fn visit_mut_ts_type_assertion(
+        &mut self,
+        node: &mut TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
-        <V as Fold>::fold_ts_type_element(&mut **self, node)
+    fn visit_mut_ts_type_element(
+        &mut self,
+        node: &mut TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
-        <V as Fold>::fold_ts_type_elements(&mut **self, node)
+    fn visit_mut_ts_type_elements(
+        &mut self,
+        node: &mut Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
-        <V as Fold>::fold_ts_type_lit(&mut **self, node)
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
-        <V as Fold>::fold_ts_type_operator(&mut **self, node)
+    fn visit_mut_ts_type_operator(
+        &mut self,
+        node: &mut TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
-        <V as Fold>::fold_ts_type_operator_op(&mut **self, node)
+    fn visit_mut_ts_type_operator_op(
+        &mut self,
+        node: &mut TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
-        <V as Fold>::fold_ts_type_param(&mut **self, node)
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
-        <V as Fold>::fold_ts_type_param_decl(&mut **self, node)
+    fn visit_mut_ts_type_param_decl(
+        &mut self,
+        node: &mut TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_param_instantiation(
+    fn visit_mut_ts_type_param_instantiation(
         &mut self,
-        node: TsTypeParamInstantiation,
-    ) -> TsTypeParamInstantiation {
-        <V as Fold>::fold_ts_type_param_instantiation(&mut **self, node)
+        node: &mut TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
-        <V as Fold>::fold_ts_type_params(&mut **self, node)
+    fn visit_mut_ts_type_params(
+        &mut self,
+        node: &mut Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
-        <V as Fold>::fold_ts_type_predicate(&mut **self, node)
+    fn visit_mut_ts_type_predicate(
+        &mut self,
+        node: &mut TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_predicate(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
-        <V as Fold>::fold_ts_type_query(&mut **self, node)
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
-        <V as Fold>::fold_ts_type_query_expr(&mut **self, node)
+    fn visit_mut_ts_type_query_expr(
+        &mut self,
+        node: &mut TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
-        <V as Fold>::fold_ts_type_ref(&mut **self, node)
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
-        <V as Fold>::fold_ts_types(&mut **self, node)
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_union_or_intersection_type(
+    fn visit_mut_ts_union_or_intersection_type(
         &mut self,
-        node: TsUnionOrIntersectionType,
-    ) -> TsUnionOrIntersectionType {
-        <V as Fold>::fold_ts_union_or_intersection_type(&mut **self, node)
+        node: &mut TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
-        <V as Fold>::fold_ts_union_type(&mut **self, node)
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_union_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
-        <V as Fold>::fold_unary_expr(&mut **self, node)
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unary_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
-        <V as Fold>::fold_unary_op(&mut **self, node)
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
-        <V as Fold>::fold_update_expr(&mut **self, node)
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_update_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
-        <V as Fold>::fold_update_op(&mut **self, node)
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_update_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
-        <V as Fold>::fold_using_decl(&mut **self, node)
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_using_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
-        <V as Fold>::fold_var_decl(&mut **self, node)
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
-        <V as Fold>::fold_var_decl_kind(&mut **self, node)
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_decl_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
-        <V as Fold>::fold_var_decl_or_expr(&mut **self, node)
+    fn visit_mut_var_decl_or_expr(
+        &mut self,
+        node: &mut VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
-        <V as Fold>::fold_var_declarator(&mut **self, node)
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_declarator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
-        <V as Fold>::fold_var_declarators(&mut **self, node)
+    fn visit_mut_var_declarators(
+        &mut self,
+        node: &mut Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_var_declarators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
-        <V as Fold>::fold_while_stmt(&mut **self, node)
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
-        <V as Fold>::fold_with_stmt(&mut **self, node)
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_with_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
-        <V as Fold>::fold_yield_expr(&mut **self, node)
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_yield_expr(&mut **self, node, __ast_path)
     }
 }
-impl<V> Fold for Box<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitMutAstPath for Box<V>
 where
-    V: ?Sized + Fold,
+    V: ?Sized + VisitMutAstPath,
 {
     #[inline]
-    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
-        <V as Fold>::fold_accessibility(&mut **self, node)
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
-        <V as Fold>::fold_array_lit(&mut **self, node)
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_array_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
-        <V as Fold>::fold_array_pat(&mut **self, node)
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_array_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
-        <V as Fold>::fold_arrow_expr(&mut **self, node)
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_arrow_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
-        <V as Fold>::fold_assign_expr(&mut **self, node)
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
-        <V as Fold>::fold_assign_op(&mut **self, node)
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
-        <V as Fold>::fold_assign_pat(&mut **self, node)
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
-        <V as Fold>::fold_assign_pat_prop(&mut **self, node)
+    fn visit_mut_assign_pat_prop(
+        &mut self,
+        node: &mut AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_assign_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
-        <V as Fold>::fold_assign_prop(&mut **self, node)
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
-        <V as Fold>::fold_assign_target(&mut **self, node)
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
-        <V as Fold>::fold_assign_target_pat(&mut **self, node)
+    fn visit_mut_assign_target_pat(
+        &mut self,
+        node: &mut AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_assign_target_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
-        <V as Fold>::fold_atom(&mut **self, node)
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
-        <V as Fold>::fold_auto_accessor(&mut **self, node)
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_auto_accessor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
-        <V as Fold>::fold_await_expr(&mut **self, node)
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_await_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
-        <V as Fold>::fold_big_int(&mut **self, node)
+    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_big_int(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
-        <V as Fold>::fold_big_int_value(&mut **self, node)
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_big_int_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
-        <V as Fold>::fold_bin_expr(&mut **self, node)
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bin_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
-        <V as Fold>::fold_binary_op(&mut **self, node)
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_binary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
-        <V as Fold>::fold_binding_ident(&mut **self, node)
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_binding_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
-        <V as Fold>::fold_block_stmt(&mut **self, node)
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
-        <V as Fold>::fold_block_stmt_or_expr(&mut **self, node)
+    fn visit_mut_block_stmt_or_expr(
+        &mut self,
+        node: &mut BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool) -> Bool {
-        <V as Fold>::fold_bool(&mut **self, node)
+    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bool(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
-        <V as Fold>::fold_break_stmt(&mut **self, node)
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_break_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
-        <V as Fold>::fold_call_expr(&mut **self, node)
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_call_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee) -> Callee {
-        <V as Fold>::fold_callee(&mut **self, node)
+    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_callee(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
-        <V as Fold>::fold_catch_clause(&mut **self, node)
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class) -> Class {
-        <V as Fold>::fold_class(&mut **self, node)
+    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
-        <V as Fold>::fold_class_decl(&mut **self, node)
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
-        <V as Fold>::fold_class_expr(&mut **self, node)
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
-        <V as Fold>::fold_class_member(&mut **self, node)
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
-        <V as Fold>::fold_class_members(&mut **self, node)
+    fn visit_mut_class_members(
+        &mut self,
+        node: &mut Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_class_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
-        <V as Fold>::fold_class_method(&mut **self, node)
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
-        <V as Fold>::fold_class_prop(&mut **self, node)
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
-        <V as Fold>::fold_computed_prop_name(&mut **self, node)
+    fn visit_mut_computed_prop_name(
+        &mut self,
+        node: &mut ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_computed_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
-        <V as Fold>::fold_cond_expr(&mut **self, node)
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_cond_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
-        <V as Fold>::fold_constructor(&mut **self, node)
+    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_constructor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
-        <V as Fold>::fold_continue_stmt(&mut **self, node)
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_continue_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
-        <V as Fold>::fold_debugger_stmt(&mut **self, node)
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_debugger_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl) -> Decl {
-        <V as Fold>::fold_decl(&mut **self, node)
+    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
-        <V as Fold>::fold_decorator(&mut **self, node)
+    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decorator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
-        <V as Fold>::fold_decorators(&mut **self, node)
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decorators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
-        <V as Fold>::fold_default_decl(&mut **self, node)
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
-        <V as Fold>::fold_do_while_stmt(&mut **self, node)
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_do_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
-        <V as Fold>::fold_empty_stmt(&mut **self, node)
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_empty_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
-        <V as Fold>::fold_es_version(&mut **self, node)
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_es_version(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
-        <V as Fold>::fold_export_all(&mut **self, node)
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_all(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
-        <V as Fold>::fold_export_decl(&mut **self, node)
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
-        <V as Fold>::fold_export_default_decl(&mut **self, node)
+    fn visit_mut_export_default_decl(
+        &mut self,
+        node: &mut ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
-        <V as Fold>::fold_export_default_expr(&mut **self, node)
+    fn visit_mut_export_default_expr(
+        &mut self,
+        node: &mut ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_default_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_default_specifier(
+    fn visit_mut_export_default_specifier(
         &mut self,
-        node: ExportDefaultSpecifier,
-    ) -> ExportDefaultSpecifier {
-        <V as Fold>::fold_export_default_specifier(&mut **self, node)
+        node: &mut ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
-        <V as Fold>::fold_export_named_specifier(&mut **self, node)
+    fn visit_mut_export_named_specifier(
+        &mut self,
+        node: &mut ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_namespace_specifier(
+    fn visit_mut_export_namespace_specifier(
         &mut self,
-        node: ExportNamespaceSpecifier,
-    ) -> ExportNamespaceSpecifier {
-        <V as Fold>::fold_export_namespace_specifier(&mut **self, node)
+        node: &mut ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
-        <V as Fold>::fold_export_specifier(&mut **self, node)
+    fn visit_mut_export_specifier(
+        &mut self,
+        node: &mut ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
-        <V as Fold>::fold_export_specifiers(&mut **self, node)
+    fn visit_mut_export_specifiers(
+        &mut self,
+        node: &mut Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_export_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr) -> Expr {
-        <V as Fold>::fold_expr(&mut **self, node)
+    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
-        <V as Fold>::fold_expr_or_spread(&mut **self, node)
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
-        <V as Fold>::fold_expr_or_spreads(&mut **self, node)
+    fn visit_mut_expr_or_spreads(
+        &mut self,
+        node: &mut Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
-        <V as Fold>::fold_expr_stmt(&mut **self, node)
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
-        <V as Fold>::fold_exprs(&mut **self, node)
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_exprs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
-        <V as Fold>::fold_fn_decl(&mut **self, node)
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_fn_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
-        <V as Fold>::fold_fn_expr(&mut **self, node)
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_fn_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
-        <V as Fold>::fold_for_head(&mut **self, node)
+    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_head(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
-        <V as Fold>::fold_for_in_stmt(&mut **self, node)
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_in_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
-        <V as Fold>::fold_for_of_stmt(&mut **self, node)
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_of_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
-        <V as Fold>::fold_for_stmt(&mut **self, node)
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
-        <V as Fold>::fold_function(&mut **self, node)
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
-        <V as Fold>::fold_getter_prop(&mut **self, node)
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_getter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
-        <V as Fold>::fold_ident(&mut **self, node)
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
-        <V as Fold>::fold_ident_name(&mut **self, node)
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
-        <V as Fold>::fold_if_stmt(&mut **self, node)
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_if_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import) -> Import {
-        <V as Fold>::fold_import(&mut **self, node)
+    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
-        <V as Fold>::fold_import_decl(&mut **self, node)
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_default_specifier(
+    fn visit_mut_import_default_specifier(
         &mut self,
-        node: ImportDefaultSpecifier,
-    ) -> ImportDefaultSpecifier {
-        <V as Fold>::fold_import_default_specifier(&mut **self, node)
+        node: &mut ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
-        <V as Fold>::fold_import_named_specifier(&mut **self, node)
+    fn visit_mut_import_named_specifier(
+        &mut self,
+        node: &mut ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
-        <V as Fold>::fold_import_phase(&mut **self, node)
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_phase(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
-        <V as Fold>::fold_import_specifier(&mut **self, node)
+    fn visit_mut_import_specifier(
+        &mut self,
+        node: &mut ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
-        <V as Fold>::fold_import_specifiers(&mut **self, node)
+    fn visit_mut_import_specifiers(
+        &mut self,
+        node: &mut Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_star_as_specifier(
+    fn visit_mut_import_star_as_specifier(
         &mut self,
-        node: ImportStarAsSpecifier,
-    ) -> ImportStarAsSpecifier {
-        <V as Fold>::fold_import_star_as_specifier(&mut **self, node)
+        node: &mut ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
-        <V as Fold>::fold_import_with(&mut **self, node)
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_with(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
-        <V as Fold>::fold_import_with_item(&mut **self, node)
+    fn visit_mut_import_with_item(
+        &mut self,
+        node: &mut ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_with_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
-        <V as Fold>::fold_import_with_items(&mut **self, node)
+    fn visit_mut_import_with_items(
+        &mut self,
+        node: &mut Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_import_with_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
-        <V as Fold>::fold_invalid(&mut **self, node)
+    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_invalid(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
-        <V as Fold>::fold_jsx_attr(&mut **self, node)
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
-        <V as Fold>::fold_jsx_attr_name(&mut **self, node)
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
-        <V as Fold>::fold_jsx_attr_or_spread(&mut **self, node)
+    fn visit_mut_jsx_attr_or_spread(
+        &mut self,
+        node: &mut JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
-        <V as Fold>::fold_jsx_attr_or_spreads(&mut **self, node)
+    fn visit_mut_jsx_attr_or_spreads(
+        &mut self,
+        node: &mut Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
-        <V as Fold>::fold_jsx_attr_value(&mut **self, node)
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
-        <V as Fold>::fold_jsx_closing_element(&mut **self, node)
+    fn visit_mut_jsx_closing_element(
+        &mut self,
+        node: &mut JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
-        <V as Fold>::fold_jsx_closing_fragment(&mut **self, node)
+    fn visit_mut_jsx_closing_fragment(
+        &mut self,
+        node: &mut JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
-        <V as Fold>::fold_jsx_element(&mut **self, node)
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
-        <V as Fold>::fold_jsx_element_child(&mut **self, node)
+    fn visit_mut_jsx_element_child(
+        &mut self,
+        node: &mut JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
-        <V as Fold>::fold_jsx_element_childs(&mut **self, node)
+    fn visit_mut_jsx_element_childs(
+        &mut self,
+        node: &mut Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_childs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
-        <V as Fold>::fold_jsx_element_name(&mut **self, node)
+    fn visit_mut_jsx_element_name(
+        &mut self,
+        node: &mut JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
-        <V as Fold>::fold_jsx_empty_expr(&mut **self, node)
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
-        <V as Fold>::fold_jsx_expr(&mut **self, node)
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
-        <V as Fold>::fold_jsx_expr_container(&mut **self, node)
+    fn visit_mut_jsx_expr_container(
+        &mut self,
+        node: &mut JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_expr_container(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
-        <V as Fold>::fold_jsx_fragment(&mut **self, node)
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
-        <V as Fold>::fold_jsx_member_expr(&mut **self, node)
+    fn visit_mut_jsx_member_expr(
+        &mut self,
+        node: &mut JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
-        <V as Fold>::fold_jsx_namespaced_name(&mut **self, node)
+    fn visit_mut_jsx_namespaced_name(
+        &mut self,
+        node: &mut JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
-        <V as Fold>::fold_jsx_object(&mut **self, node)
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_object(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
-        <V as Fold>::fold_jsx_opening_element(&mut **self, node)
+    fn visit_mut_jsx_opening_element(
+        &mut self,
+        node: &mut JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_opening_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
-        <V as Fold>::fold_jsx_opening_fragment(&mut **self, node)
+    fn visit_mut_jsx_opening_fragment(
+        &mut self,
+        node: &mut JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
-        <V as Fold>::fold_jsx_spread_child(&mut **self, node)
+    fn visit_mut_jsx_spread_child(
+        &mut self,
+        node: &mut JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_jsx_spread_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
-        <V as Fold>::fold_jsx_text(&mut **self, node)
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_text(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key) -> Key {
-        <V as Fold>::fold_key(&mut **self, node)
+    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_key(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
-        <V as Fold>::fold_key_value_pat_prop(&mut **self, node)
+    fn visit_mut_key_value_pat_prop(
+        &mut self,
+        node: &mut KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
-        <V as Fold>::fold_key_value_prop(&mut **self, node)
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_key_value_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
-        <V as Fold>::fold_labeled_stmt(&mut **self, node)
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_labeled_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit) -> Lit {
-        <V as Fold>::fold_lit(&mut **self, node)
+    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
-        <V as Fold>::fold_member_expr(&mut **self, node)
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
-        <V as Fold>::fold_member_prop(&mut **self, node)
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_member_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
-        <V as Fold>::fold_meta_prop_expr(&mut **self, node)
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_meta_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
-        <V as Fold>::fold_meta_prop_kind(&mut **self, node)
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_meta_prop_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
-        <V as Fold>::fold_method_kind(&mut **self, node)
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_method_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
-        <V as Fold>::fold_method_prop(&mut **self, node)
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_method_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module) -> Module {
-        <V as Fold>::fold_module(&mut **self, node)
+    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
-        <V as Fold>::fold_module_decl(&mut **self, node)
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
-        <V as Fold>::fold_module_export_name(&mut **self, node)
+    fn visit_mut_module_export_name(
+        &mut self,
+        node: &mut ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
-        <V as Fold>::fold_module_item(&mut **self, node)
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
-        <V as Fold>::fold_module_items(&mut **self, node)
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
-        <V as Fold>::fold_named_export(&mut **self, node)
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_named_export(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
-        <V as Fold>::fold_new_expr(&mut **self, node)
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_new_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null) -> Null {
-        <V as Fold>::fold_null(&mut **self, node)
+    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_null(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
-        <V as Fold>::fold_number(&mut **self, node)
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
-        <V as Fold>::fold_object_lit(&mut **self, node)
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
-        <V as Fold>::fold_object_pat(&mut **self, node)
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
-        <V as Fold>::fold_object_pat_prop(&mut **self, node)
+    fn visit_mut_object_pat_prop(
+        &mut self,
+        node: &mut ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_object_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
-        <V as Fold>::fold_object_pat_props(&mut **self, node)
+    fn visit_mut_object_pat_props(
+        &mut self,
+        node: &mut Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_object_pat_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
-        <V as Fold>::fold_opt_accessibility(&mut **self, node)
+    fn visit_mut_opt_accessibility(
+        &mut self,
+        node: &mut Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
-        <V as Fold>::fold_opt_atom(&mut **self, node)
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
-        <V as Fold>::fold_opt_block_stmt(&mut **self, node)
+    fn visit_mut_opt_block_stmt(
+        &mut self,
+        node: &mut Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
-        <V as Fold>::fold_opt_call(&mut **self, node)
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_call(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
-        <V as Fold>::fold_opt_catch_clause(&mut **self, node)
+    fn visit_mut_opt_catch_clause(
+        &mut self,
+        node: &mut Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
-        <V as Fold>::fold_opt_chain_base(&mut **self, node)
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_chain_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
-        <V as Fold>::fold_opt_chain_expr(&mut **self, node)
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_chain_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
-        <V as Fold>::fold_opt_expr(&mut **self, node)
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
-        <V as Fold>::fold_opt_expr_or_spread(&mut **self, node)
+    fn visit_mut_opt_expr_or_spread(
+        &mut self,
+        node: &mut Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_expr_or_spreads(
+    fn visit_mut_opt_expr_or_spreads(
         &mut self,
-        node: Option<Vec<ExprOrSpread>>,
-    ) -> Option<Vec<ExprOrSpread>> {
-        <V as Fold>::fold_opt_expr_or_spreads(&mut **self, node)
+        node: &mut Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
-        <V as Fold>::fold_opt_ident(&mut **self, node)
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
-        <V as Fold>::fold_opt_jsx_attr_value(&mut **self, node)
+    fn visit_mut_opt_jsx_attr_value(
+        &mut self,
+        node: &mut Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_jsx_closing_element(
+    fn visit_mut_opt_jsx_closing_element(
         &mut self,
-        node: Option<JSXClosingElement>,
-    ) -> Option<JSXClosingElement> {
-        <V as Fold>::fold_opt_jsx_closing_element(&mut **self, node)
+        node: &mut Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_module_export_name(
+    fn visit_mut_opt_module_export_name(
         &mut self,
-        node: Option<ModuleExportName>,
-    ) -> Option<ModuleExportName> {
-        <V as Fold>::fold_opt_module_export_name(&mut **self, node)
+        node: &mut Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
-        <V as Fold>::fold_opt_object_lit(&mut **self, node)
+    fn visit_mut_opt_object_lit(
+        &mut self,
+        node: &mut Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
-        <V as Fold>::fold_opt_pat(&mut **self, node)
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
-        <V as Fold>::fold_opt_span(&mut **self, node)
+    fn visit_mut_opt_span(
+        &mut self,
+        node: &mut Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
-        <V as Fold>::fold_opt_stmt(&mut **self, node)
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
-        <V as Fold>::fold_opt_str(&mut **self, node)
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
-        <V as Fold>::fold_opt_true_plus_minus(&mut **self, node)
+    fn visit_mut_opt_true_plus_minus(
+        &mut self,
+        node: &mut Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
-        <V as Fold>::fold_opt_ts_entity_name(&mut **self, node)
+    fn visit_mut_opt_ts_entity_name(
+        &mut self,
+        node: &mut Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_namespace_body(
+    fn visit_mut_opt_ts_namespace_body(
         &mut self,
-        node: Option<TsNamespaceBody>,
-    ) -> Option<TsNamespaceBody> {
-        <V as Fold>::fold_opt_ts_namespace_body(&mut **self, node)
+        node: &mut Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
-        <V as Fold>::fold_opt_ts_type(&mut **self, node)
+    fn visit_mut_opt_ts_type(
+        &mut self,
+        node: &mut Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
-        <V as Fold>::fold_opt_ts_type_ann(&mut **self, node)
+    fn visit_mut_opt_ts_type_ann(
+        &mut self,
+        node: &mut Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_decl(
+    fn visit_mut_opt_ts_type_param_decl(
         &mut self,
-        node: Option<Box<TsTypeParamDecl>>,
-    ) -> Option<Box<TsTypeParamDecl>> {
-        <V as Fold>::fold_opt_ts_type_param_decl(&mut **self, node)
+        node: &mut Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_instantiation(
+    fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
-        node: Option<Box<TsTypeParamInstantiation>>,
-    ) -> Option<Box<TsTypeParamInstantiation>> {
-        <V as Fold>::fold_opt_ts_type_param_instantiation(&mut **self, node)
+        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
-        <V as Fold>::fold_opt_var_decl_or_expr(&mut **self, node)
+    fn visit_mut_opt_var_decl_or_expr(
+        &mut self,
+        node: &mut Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_vec_expr_or_spreads(
+    fn visit_mut_opt_vec_expr_or_spreads(
         &mut self,
-        node: Vec<Option<ExprOrSpread>>,
-    ) -> Vec<Option<ExprOrSpread>> {
-        <V as Fold>::fold_opt_vec_expr_or_spreads(&mut **self, node)
+        node: &mut Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
-        <V as Fold>::fold_opt_vec_pats(&mut **self, node)
+    fn visit_mut_opt_vec_pats(
+        &mut self,
+        node: &mut Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_opt_vec_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param) -> Param {
-        <V as Fold>::fold_param(&mut **self, node)
+    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
-        <V as Fold>::fold_param_or_ts_param_prop(&mut **self, node)
+    fn visit_mut_param_or_ts_param_prop(
+        &mut self,
+        node: &mut ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_param_or_ts_param_props(
+    fn visit_mut_param_or_ts_param_props(
         &mut self,
-        node: Vec<ParamOrTsParamProp>,
-    ) -> Vec<ParamOrTsParamProp> {
-        <V as Fold>::fold_param_or_ts_param_props(&mut **self, node)
+        node: &mut Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
-        <V as Fold>::fold_params(&mut **self, node)
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
-        <V as Fold>::fold_paren_expr(&mut **self, node)
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_paren_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat) -> Pat {
-        <V as Fold>::fold_pat(&mut **self, node)
+    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
-        <V as Fold>::fold_pats(&mut **self, node)
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
-        <V as Fold>::fold_private_method(&mut **self, node)
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
-        <V as Fold>::fold_private_name(&mut **self, node)
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
-        <V as Fold>::fold_private_prop(&mut **self, node)
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program) -> Program {
-        <V as Fold>::fold_program(&mut **self, node)
+    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_program(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop) -> Prop {
-        <V as Fold>::fold_prop(&mut **self, node)
+    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName) -> PropName {
-        <V as Fold>::fold_prop_name(&mut **self, node)
+    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
-        <V as Fold>::fold_prop_or_spread(&mut **self, node)
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
-        <V as Fold>::fold_prop_or_spreads(&mut **self, node)
+    fn visit_mut_prop_or_spreads(
+        &mut self,
+        node: &mut Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_prop_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex) -> Regex {
-        <V as Fold>::fold_regex(&mut **self, node)
+    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_regex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
-        <V as Fold>::fold_rest_pat(&mut **self, node)
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rest_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
-        <V as Fold>::fold_return_stmt(&mut **self, node)
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_return_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script) -> Script {
-        <V as Fold>::fold_script(&mut **self, node)
+    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_script(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
-        <V as Fold>::fold_seq_expr(&mut **self, node)
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_seq_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
-        <V as Fold>::fold_setter_prop(&mut **self, node)
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_setter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
-        <V as Fold>::fold_simple_assign_target(&mut **self, node)
+    fn visit_mut_simple_assign_target(
+        &mut self,
+        node: &mut SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_simple_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
-        <V as Fold>::fold_span(&mut **self, node)
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
-        <V as Fold>::fold_spread_element(&mut **self, node)
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_spread_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
-        <V as Fold>::fold_static_block(&mut **self, node)
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_static_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
-        <V as Fold>::fold_stmt(&mut **self, node)
+    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
-        <V as Fold>::fold_stmts(&mut **self, node)
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stmts(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
-        <V as Fold>::fold_str(&mut **self, node)
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super) -> Super {
-        <V as Fold>::fold_super(&mut **self, node)
+    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_super(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
-        <V as Fold>::fold_super_prop(&mut **self, node)
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_super_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
-        <V as Fold>::fold_super_prop_expr(&mut **self, node)
+    fn visit_mut_super_prop_expr(
+        &mut self,
+        node: &mut SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_super_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
-        <V as Fold>::fold_switch_case(&mut **self, node)
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_case(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
-        <V as Fold>::fold_switch_cases(&mut **self, node)
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_cases(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
-        <V as Fold>::fold_switch_stmt(&mut **self, node)
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_syntax_context(
+    fn visit_mut_syntax_context(
         &mut self,
-        node: swc_common::SyntaxContext,
-    ) -> swc_common::SyntaxContext {
-        <V as Fold>::fold_syntax_context(&mut **self, node)
+        node: &mut swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_syntax_context(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
-        <V as Fold>::fold_tagged_tpl(&mut **self, node)
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tagged_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
-        <V as Fold>::fold_this_expr(&mut **self, node)
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_this_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
-        <V as Fold>::fold_throw_stmt(&mut **self, node)
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_throw_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
-        <V as Fold>::fold_tpl(&mut **self, node)
+    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
-        <V as Fold>::fold_tpl_element(&mut **self, node)
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
-        <V as Fold>::fold_tpl_elements(&mut **self, node)
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
-        <V as Fold>::fold_true_plus_minus(&mut **self, node)
+    fn visit_mut_true_plus_minus(
+        &mut self,
+        node: &mut TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
-        <V as Fold>::fold_try_stmt(&mut **self, node)
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_try_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
-        <V as Fold>::fold_ts_array_type(&mut **self, node)
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_array_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
-        <V as Fold>::fold_ts_as_expr(&mut **self, node)
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_as_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
-        <V as Fold>::fold_ts_call_signature_decl(&mut **self, node)
+    fn visit_mut_ts_call_signature_decl(
+        &mut self,
+        node: &mut TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
-        <V as Fold>::fold_ts_conditional_type(&mut **self, node)
+    fn visit_mut_ts_conditional_type(
+        &mut self,
+        node: &mut TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_conditional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
-        <V as Fold>::fold_ts_const_assertion(&mut **self, node)
+    fn visit_mut_ts_const_assertion(
+        &mut self,
+        node: &mut TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_const_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_construct_signature_decl(
+    fn visit_mut_ts_construct_signature_decl(
         &mut self,
-        node: TsConstructSignatureDecl,
-    ) -> TsConstructSignatureDecl {
-        <V as Fold>::fold_ts_construct_signature_decl(&mut **self, node)
+        node: &mut TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
-        <V as Fold>::fold_ts_constructor_type(&mut **self, node)
+    fn visit_mut_ts_constructor_type(
+        &mut self,
+        node: &mut TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
-        <V as Fold>::fold_ts_entity_name(&mut **self, node)
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
-        <V as Fold>::fold_ts_enum_decl(&mut **self, node)
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
-        <V as Fold>::fold_ts_enum_member(&mut **self, node)
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
-        <V as Fold>::fold_ts_enum_member_id(&mut **self, node)
+    fn visit_mut_ts_enum_member_id(
+        &mut self,
+        node: &mut TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
-        <V as Fold>::fold_ts_enum_members(&mut **self, node)
+    fn visit_mut_ts_enum_members(
+        &mut self,
+        node: &mut Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
-        <V as Fold>::fold_ts_export_assignment(&mut **self, node)
+    fn visit_mut_ts_export_assignment(
+        &mut self,
+        node: &mut TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_export_assignment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
-        <V as Fold>::fold_ts_expr_with_type_args(&mut **self, node)
+    fn visit_mut_ts_expr_with_type_args(
+        &mut self,
+        node: &mut TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_argss(
+    fn visit_mut_ts_expr_with_type_argss(
         &mut self,
-        node: Vec<TsExprWithTypeArgs>,
-    ) -> Vec<TsExprWithTypeArgs> {
-        <V as Fold>::fold_ts_expr_with_type_argss(&mut **self, node)
+        node: &mut Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
-        <V as Fold>::fold_ts_external_module_ref(&mut **self, node)
+    fn visit_mut_ts_external_module_ref(
+        &mut self,
+        node: &mut TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_or_constructor_type(
+    fn visit_mut_ts_fn_or_constructor_type(
         &mut self,
-        node: TsFnOrConstructorType,
-    ) -> TsFnOrConstructorType {
-        <V as Fold>::fold_ts_fn_or_constructor_type(&mut **self, node)
+        node: &mut TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
-        <V as Fold>::fold_ts_fn_param(&mut **self, node)
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
-        <V as Fold>::fold_ts_fn_params(&mut **self, node)
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
-        <V as Fold>::fold_ts_fn_type(&mut **self, node)
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
-        <V as Fold>::fold_ts_getter_signature(&mut **self, node)
+    fn visit_mut_ts_getter_signature(
+        &mut self,
+        node: &mut TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_getter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
-        <V as Fold>::fold_ts_import_equals_decl(&mut **self, node)
+    fn visit_mut_ts_import_equals_decl(
+        &mut self,
+        node: &mut TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
-        <V as Fold>::fold_ts_import_type(&mut **self, node)
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_import_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
-        <V as Fold>::fold_ts_index_signature(&mut **self, node)
+    fn visit_mut_ts_index_signature(
+        &mut self,
+        node: &mut TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_index_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
-        <V as Fold>::fold_ts_indexed_access_type(&mut **self, node)
+    fn visit_mut_ts_indexed_access_type(
+        &mut self,
+        node: &mut TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
-        <V as Fold>::fold_ts_infer_type(&mut **self, node)
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_infer_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
-        <V as Fold>::fold_ts_instantiation(&mut **self, node)
+    fn visit_mut_ts_instantiation(
+        &mut self,
+        node: &mut TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
-        <V as Fold>::fold_ts_interface_body(&mut **self, node)
+    fn visit_mut_ts_interface_body(
+        &mut self,
+        node: &mut TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_interface_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
-        <V as Fold>::fold_ts_interface_decl(&mut **self, node)
+    fn visit_mut_ts_interface_decl(
+        &mut self,
+        node: &mut TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_interface_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
-        <V as Fold>::fold_ts_intersection_type(&mut **self, node)
+    fn visit_mut_ts_intersection_type(
+        &mut self,
+        node: &mut TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
-        <V as Fold>::fold_ts_keyword_type(&mut **self, node)
+    fn visit_mut_ts_keyword_type(
+        &mut self,
+        node: &mut TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_keyword_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
-        <V as Fold>::fold_ts_keyword_type_kind(&mut **self, node)
+    fn visit_mut_ts_keyword_type_kind(
+        &mut self,
+        node: &mut TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
-        <V as Fold>::fold_ts_lit(&mut **self, node)
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
-        <V as Fold>::fold_ts_lit_type(&mut **self, node)
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
-        <V as Fold>::fold_ts_mapped_type(&mut **self, node)
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_mapped_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
-        <V as Fold>::fold_ts_method_signature(&mut **self, node)
+    fn visit_mut_ts_method_signature(
+        &mut self,
+        node: &mut TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_method_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
-        <V as Fold>::fold_ts_module_block(&mut **self, node)
+    fn visit_mut_ts_module_block(
+        &mut self,
+        node: &mut TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
-        <V as Fold>::fold_ts_module_decl(&mut **self, node)
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
-        <V as Fold>::fold_ts_module_name(&mut **self, node)
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
-        <V as Fold>::fold_ts_module_ref(&mut **self, node)
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
-        <V as Fold>::fold_ts_namespace_body(&mut **self, node)
+    fn visit_mut_ts_namespace_body(
+        &mut self,
+        node: &mut TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
-        <V as Fold>::fold_ts_namespace_decl(&mut **self, node)
+    fn visit_mut_ts_namespace_decl(
+        &mut self,
+        node: &mut TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_namespace_export_decl(
+    fn visit_mut_ts_namespace_export_decl(
         &mut self,
-        node: TsNamespaceExportDecl,
-    ) -> TsNamespaceExportDecl {
-        <V as Fold>::fold_ts_namespace_export_decl(&mut **self, node)
+        node: &mut TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
-        <V as Fold>::fold_ts_non_null_expr(&mut **self, node)
+    fn visit_mut_ts_non_null_expr(
+        &mut self,
+        node: &mut TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
-        <V as Fold>::fold_ts_optional_type(&mut **self, node)
+    fn visit_mut_ts_optional_type(
+        &mut self,
+        node: &mut TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_optional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
-        <V as Fold>::fold_ts_param_prop(&mut **self, node)
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
-        <V as Fold>::fold_ts_param_prop_param(&mut **self, node)
+    fn visit_mut_ts_param_prop_param(
+        &mut self,
+        node: &mut TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
-        <V as Fold>::fold_ts_parenthesized_type(&mut **self, node)
+    fn visit_mut_ts_parenthesized_type(
+        &mut self,
+        node: &mut TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
-        <V as Fold>::fold_ts_property_signature(&mut **self, node)
+    fn visit_mut_ts_property_signature(
+        &mut self,
+        node: &mut TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_property_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
-        <V as Fold>::fold_ts_qualified_name(&mut **self, node)
+    fn visit_mut_ts_qualified_name(
+        &mut self,
+        node: &mut TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_qualified_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
-        <V as Fold>::fold_ts_rest_type(&mut **self, node)
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_rest_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
-        <V as Fold>::fold_ts_satisfies_expr(&mut **self, node)
+    fn visit_mut_ts_satisfies_expr(
+        &mut self,
+        node: &mut TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
-        <V as Fold>::fold_ts_setter_signature(&mut **self, node)
+    fn visit_mut_ts_setter_signature(
+        &mut self,
+        node: &mut TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_setter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
-        <V as Fold>::fold_ts_this_type(&mut **self, node)
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_this_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
-        <V as Fold>::fold_ts_this_type_or_ident(&mut **self, node)
+    fn visit_mut_ts_this_type_or_ident(
+        &mut self,
+        node: &mut TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
-        <V as Fold>::fold_ts_tpl_lit_type(&mut **self, node)
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
-        <V as Fold>::fold_ts_tuple_element(&mut **self, node)
+    fn visit_mut_ts_tuple_element(
+        &mut self,
+        node: &mut TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
-        <V as Fold>::fold_ts_tuple_elements(&mut **self, node)
+    fn visit_mut_ts_tuple_elements(
+        &mut self,
+        node: &mut Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
-        <V as Fold>::fold_ts_tuple_type(&mut **self, node)
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType) -> TsType {
-        <V as Fold>::fold_ts_type(&mut **self, node)
+    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
-        <V as Fold>::fold_ts_type_alias_decl(&mut **self, node)
+    fn visit_mut_ts_type_alias_decl(
+        &mut self,
+        node: &mut TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
-        <V as Fold>::fold_ts_type_ann(&mut **self, node)
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
-        <V as Fold>::fold_ts_type_assertion(&mut **self, node)
+    fn visit_mut_ts_type_assertion(
+        &mut self,
+        node: &mut TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
-        <V as Fold>::fold_ts_type_element(&mut **self, node)
+    fn visit_mut_ts_type_element(
+        &mut self,
+        node: &mut TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
-        <V as Fold>::fold_ts_type_elements(&mut **self, node)
+    fn visit_mut_ts_type_elements(
+        &mut self,
+        node: &mut Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
-        <V as Fold>::fold_ts_type_lit(&mut **self, node)
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
-        <V as Fold>::fold_ts_type_operator(&mut **self, node)
+    fn visit_mut_ts_type_operator(
+        &mut self,
+        node: &mut TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
-        <V as Fold>::fold_ts_type_operator_op(&mut **self, node)
+    fn visit_mut_ts_type_operator_op(
+        &mut self,
+        node: &mut TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
-        <V as Fold>::fold_ts_type_param(&mut **self, node)
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
-        <V as Fold>::fold_ts_type_param_decl(&mut **self, node)
+    fn visit_mut_ts_type_param_decl(
+        &mut self,
+        node: &mut TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_param_instantiation(
+    fn visit_mut_ts_type_param_instantiation(
         &mut self,
-        node: TsTypeParamInstantiation,
-    ) -> TsTypeParamInstantiation {
-        <V as Fold>::fold_ts_type_param_instantiation(&mut **self, node)
+        node: &mut TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
-        <V as Fold>::fold_ts_type_params(&mut **self, node)
+    fn visit_mut_ts_type_params(
+        &mut self,
+        node: &mut Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
-        <V as Fold>::fold_ts_type_predicate(&mut **self, node)
+    fn visit_mut_ts_type_predicate(
+        &mut self,
+        node: &mut TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_predicate(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
-        <V as Fold>::fold_ts_type_query(&mut **self, node)
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
-        <V as Fold>::fold_ts_type_query_expr(&mut **self, node)
+    fn visit_mut_ts_type_query_expr(
+        &mut self,
+        node: &mut TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
-        <V as Fold>::fold_ts_type_ref(&mut **self, node)
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
-        <V as Fold>::fold_ts_types(&mut **self, node)
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_ts_union_or_intersection_type(
+    fn visit_mut_ts_union_or_intersection_type(
         &mut self,
-        node: TsUnionOrIntersectionType,
-    ) -> TsUnionOrIntersectionType {
-        <V as Fold>::fold_ts_union_or_intersection_type(&mut **self, node)
+        node: &mut TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(
+            &mut **self,
+            node,
+            __ast_path,
+        )
     }
 
     #[inline]
-    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
-        <V as Fold>::fold_ts_union_type(&mut **self, node)
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_union_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
-        <V as Fold>::fold_unary_expr(&mut **self, node)
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unary_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
-        <V as Fold>::fold_unary_op(&mut **self, node)
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
-        <V as Fold>::fold_update_expr(&mut **self, node)
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_update_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
-        <V as Fold>::fold_update_op(&mut **self, node)
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_update_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
-        <V as Fold>::fold_using_decl(&mut **self, node)
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_using_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
-        <V as Fold>::fold_var_decl(&mut **self, node)
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
-        <V as Fold>::fold_var_decl_kind(&mut **self, node)
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_decl_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
-        <V as Fold>::fold_var_decl_or_expr(&mut **self, node)
+    fn visit_mut_var_decl_or_expr(
+        &mut self,
+        node: &mut VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
-        <V as Fold>::fold_var_declarator(&mut **self, node)
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_declarator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
-        <V as Fold>::fold_var_declarators(&mut **self, node)
+    fn visit_mut_var_declarators(
+        &mut self,
+        node: &mut Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) {
+        <V as VisitMutAstPath>::visit_mut_var_declarators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
-        <V as Fold>::fold_while_stmt(&mut **self, node)
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
-        <V as Fold>::fold_with_stmt(&mut **self, node)
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_with_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
-        <V as Fold>::fold_yield_expr(&mut **self, node)
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_yield_expr(&mut **self, node, __ast_path)
     }
 }
-impl<A, B> Fold for ::swc_visit::Either<A, B>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<A, B> VisitMutAstPath for ::swc_visit::Either<A, B>
 where
-    A: Fold,
-    B: Fold,
+    A: VisitMutAstPath,
+    B: VisitMutAstPath,
 {
     #[inline]
-    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_accessibility(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_accessibility(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_accessibility(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_accessibility(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_array_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_array_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_array_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_array_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_array_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_array_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_array_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_array_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_arrow_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_arrow_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_arrow_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_arrow_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_assign_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_assign_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_assign_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_assign_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_assign_op(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_assign_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_assign_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_assign_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_assign_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_assign_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_assign_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_assign_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
+    fn visit_mut_assign_pat_prop(
+        &mut self,
+        node: &mut AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_assign_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_assign_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_assign_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_assign_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_assign_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_assign_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_assign_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_assign_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_assign_target(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_assign_target(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_assign_target(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_assign_target(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
+    fn visit_mut_assign_target_pat(
+        &mut self,
+        node: &mut AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_assign_target_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_assign_target_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_assign_target_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_assign_target_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_auto_accessor(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_auto_accessor(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_auto_accessor(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_auto_accessor(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_await_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_await_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_await_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_await_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
+    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_big_int(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_big_int(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_big_int(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_big_int(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_big_int_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_big_int_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_big_int_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_big_int_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_bin_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_bin_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_bin_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_bin_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_binary_op(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_binary_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_binary_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_binary_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_binding_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_binding_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_binding_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_binding_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_block_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_block_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_block_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_block_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
+    fn visit_mut_block_stmt_or_expr(
+        &mut self,
+        node: &mut BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_block_stmt_or_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_block_stmt_or_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_block_stmt_or_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_block_stmt_or_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool) -> Bool {
+    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_bool(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_bool(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_bool(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_bool(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_break_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_break_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_break_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_break_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_call_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_call_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_call_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_call_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee) -> Callee {
+    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_callee(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_callee(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_callee(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_callee(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_catch_clause(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_catch_clause(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_catch_clause(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_catch_clause(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class) -> Class {
+    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class_member(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class_member(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class_member(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class_member(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
+    fn visit_mut_class_members(
+        &mut self,
+        node: &mut Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class_members(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class_members(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class_members(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class_members(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class_method(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class_method(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class_method(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class_method(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_class_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_class_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_class_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_class_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
+    fn visit_mut_computed_prop_name(
+        &mut self,
+        node: &mut ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_computed_prop_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_computed_prop_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_computed_prop_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_computed_prop_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_cond_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_cond_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_cond_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_cond_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
+    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_constructor(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_constructor(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_constructor(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_constructor(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_continue_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_continue_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_continue_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_continue_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_debugger_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_debugger_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_debugger_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_debugger_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl) -> Decl {
+    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
+    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_decorator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_decorator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_decorator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_decorator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_decorators(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_decorators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_decorators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_decorators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_default_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_default_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_default_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_default_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_do_while_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_do_while_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_do_while_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_do_while_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_empty_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_empty_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_empty_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_empty_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_es_version(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_es_version(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_es_version(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_es_version(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_all(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_all(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_all(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_all(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
+    fn visit_mut_export_default_decl(
+        &mut self,
+        node: &mut ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_default_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_default_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_default_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_default_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
+    fn visit_mut_export_default_expr(
+        &mut self,
+        node: &mut ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_default_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_default_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_default_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_default_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_default_specifier(
+    fn visit_mut_export_default_specifier(
         &mut self,
-        node: ExportDefaultSpecifier,
-    ) -> ExportDefaultSpecifier {
+        node: &mut ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_default_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_default_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_default_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_default_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
+    fn visit_mut_export_named_specifier(
+        &mut self,
+        node: &mut ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_named_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_named_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_named_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_named_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_namespace_specifier(
+    fn visit_mut_export_namespace_specifier(
         &mut self,
-        node: ExportNamespaceSpecifier,
-    ) -> ExportNamespaceSpecifier {
+        node: &mut ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_export_namespace_specifier(visitor, node)
+                VisitMutAstPath::visit_mut_export_namespace_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_export_namespace_specifier(visitor, node)
+                VisitMutAstPath::visit_mut_export_namespace_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
+    fn visit_mut_export_specifier(
+        &mut self,
+        node: &mut ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
+    fn visit_mut_export_specifiers(
+        &mut self,
+        node: &mut Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_export_specifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_export_specifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_export_specifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_export_specifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr) -> Expr {
+    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_expr_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_expr_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_expr_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_expr_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
+    fn visit_mut_expr_or_spreads(
+        &mut self,
+        node: &mut Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_expr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_expr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_expr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_expr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_expr_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_expr_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_expr_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_expr_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_exprs(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_exprs(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_exprs(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_exprs(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_fn_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_fn_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_fn_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_fn_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_fn_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_fn_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_fn_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_fn_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
+    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_for_head(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_for_head(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_for_head(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_for_head(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_for_in_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_for_in_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_for_in_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_for_in_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_for_of_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_for_of_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_for_of_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_for_of_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_for_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_for_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_for_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_for_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_function(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_getter_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_getter_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_getter_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_getter_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ident_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ident_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ident_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ident_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_if_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_if_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_if_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_if_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import) -> Import {
+    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_default_specifier(
+    fn visit_mut_import_default_specifier(
         &mut self,
-        node: ImportDefaultSpecifier,
-    ) -> ImportDefaultSpecifier {
+        node: &mut ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_default_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_default_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_default_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_default_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
+    fn visit_mut_import_named_specifier(
+        &mut self,
+        node: &mut ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_named_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_named_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_named_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_named_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_phase(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_phase(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_phase(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_phase(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
+    fn visit_mut_import_specifier(
+        &mut self,
+        node: &mut ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
+    fn visit_mut_import_specifiers(
+        &mut self,
+        node: &mut Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_specifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_specifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_specifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_specifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_star_as_specifier(
+    fn visit_mut_import_star_as_specifier(
         &mut self,
-        node: ImportStarAsSpecifier,
-    ) -> ImportStarAsSpecifier {
+        node: &mut ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_star_as_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_star_as_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_star_as_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_star_as_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_with(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_with(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_with(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_with(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
+    fn visit_mut_import_with_item(
+        &mut self,
+        node: &mut ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_with_item(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_with_item(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_with_item(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_with_item(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
+    fn visit_mut_import_with_items(
+        &mut self,
+        node: &mut Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_import_with_items(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_import_with_items(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_import_with_items(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_import_with_items(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
+    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_invalid(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_invalid(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_invalid(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_invalid(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
+    fn visit_mut_jsx_attr_or_spread(
+        &mut self,
+        node: &mut JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
+    fn visit_mut_jsx_attr_or_spreads(
+        &mut self,
+        node: &mut Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_attr_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
+    fn visit_mut_jsx_closing_element(
+        &mut self,
+        node: &mut JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_closing_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_closing_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_closing_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_closing_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
+    fn visit_mut_jsx_closing_fragment(
+        &mut self,
+        node: &mut JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_closing_fragment(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_closing_fragment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_closing_fragment(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_closing_fragment(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
+    fn visit_mut_jsx_element_child(
+        &mut self,
+        node: &mut JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element_child(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element_child(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element_child(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element_child(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
+    fn visit_mut_jsx_element_childs(
+        &mut self,
+        node: &mut Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element_childs(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element_childs(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element_childs(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element_childs(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
+    fn visit_mut_jsx_element_name(
+        &mut self,
+        node: &mut JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_element_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_empty_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_empty_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_empty_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_empty_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
+    fn visit_mut_jsx_expr_container(
+        &mut self,
+        node: &mut JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_expr_container(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_expr_container(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_expr_container(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_expr_container(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_fragment(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_fragment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_fragment(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_fragment(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
+    fn visit_mut_jsx_member_expr(
+        &mut self,
+        node: &mut JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_member_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_member_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_member_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_member_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
+    fn visit_mut_jsx_namespaced_name(
+        &mut self,
+        node: &mut JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_namespaced_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_namespaced_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_namespaced_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_namespaced_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_object(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_object(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_object(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_object(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
+    fn visit_mut_jsx_opening_element(
+        &mut self,
+        node: &mut JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_opening_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_opening_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_opening_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_opening_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
+    fn visit_mut_jsx_opening_fragment(
+        &mut self,
+        node: &mut JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_opening_fragment(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_opening_fragment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_opening_fragment(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_opening_fragment(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
+    fn visit_mut_jsx_spread_child(
+        &mut self,
+        node: &mut JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_spread_child(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_spread_child(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_spread_child(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_spread_child(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_jsx_text(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_jsx_text(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_text(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_jsx_text(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key) -> Key {
+    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_key(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_key(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_key(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_key(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
+    fn visit_mut_key_value_pat_prop(
+        &mut self,
+        node: &mut KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_key_value_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_key_value_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_key_value_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_key_value_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_key_value_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_key_value_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_key_value_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_key_value_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_labeled_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_labeled_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_labeled_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_labeled_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit) -> Lit {
+    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_member_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_member_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_member_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_member_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_member_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_member_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_member_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_member_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_meta_prop_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_meta_prop_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_meta_prop_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_meta_prop_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_meta_prop_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_meta_prop_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_meta_prop_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_meta_prop_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_method_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_method_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_method_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_method_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_method_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_method_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_method_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_method_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module) -> Module {
+    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_module(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_module(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_module(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_module(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_module_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_module_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_module_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_module_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
+    fn visit_mut_module_export_name(
+        &mut self,
+        node: &mut ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_module_export_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_module_export_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_module_export_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_module_export_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_module_item(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_module_item(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_module_item(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_module_item(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_module_items(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_module_items(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_module_items(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_module_items(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_named_export(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_named_export(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_named_export(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_named_export(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_new_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_new_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_new_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_new_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null) -> Null {
+    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_null(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_null(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_null(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_null(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_number(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_number(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_number(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_object_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_object_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_object_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_object_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_object_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_object_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_object_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_object_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
+    fn visit_mut_object_pat_prop(
+        &mut self,
+        node: &mut ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_object_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_object_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_object_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_object_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
+    fn visit_mut_object_pat_props(
+        &mut self,
+        node: &mut Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_object_pat_props(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_object_pat_props(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_object_pat_props(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_object_pat_props(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
+    fn visit_mut_opt_accessibility(
+        &mut self,
+        node: &mut Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_accessibility(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_accessibility(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_accessibility(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_accessibility(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
+    fn visit_mut_opt_block_stmt(
+        &mut self,
+        node: &mut Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_block_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_block_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_block_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_block_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_call(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_call(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_call(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_call(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
+    fn visit_mut_opt_catch_clause(
+        &mut self,
+        node: &mut Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_catch_clause(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_catch_clause(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_catch_clause(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_catch_clause(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_chain_base(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_chain_base(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_chain_base(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_chain_base(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_chain_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_chain_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_chain_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_chain_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
+    fn visit_mut_opt_expr_or_spread(
+        &mut self,
+        node: &mut Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_expr_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_expr_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_expr_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_expr_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_expr_or_spreads(
+    fn visit_mut_opt_expr_or_spreads(
         &mut self,
-        node: Option<Vec<ExprOrSpread>>,
-    ) -> Option<Vec<ExprOrSpread>> {
+        node: &mut Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_expr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_expr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_expr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_expr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
+    fn visit_mut_opt_jsx_attr_value(
+        &mut self,
+        node: &mut Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_jsx_attr_value(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_jsx_attr_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_jsx_attr_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_jsx_attr_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_jsx_closing_element(
+    fn visit_mut_opt_jsx_closing_element(
         &mut self,
-        node: Option<JSXClosingElement>,
-    ) -> Option<JSXClosingElement> {
+        node: &mut Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_jsx_closing_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_jsx_closing_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_jsx_closing_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_jsx_closing_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_module_export_name(
+    fn visit_mut_opt_module_export_name(
         &mut self,
-        node: Option<ModuleExportName>,
-    ) -> Option<ModuleExportName> {
+        node: &mut Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_module_export_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_module_export_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_module_export_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_module_export_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
+    fn visit_mut_opt_object_lit(
+        &mut self,
+        node: &mut Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_object_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_object_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_object_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_object_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
+    fn visit_mut_opt_span(
+        &mut self,
+        node: &mut Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_span(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_str(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_str(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_str(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_str(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
+    fn visit_mut_opt_true_plus_minus(
+        &mut self,
+        node: &mut Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_true_plus_minus(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_true_plus_minus(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_true_plus_minus(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_true_plus_minus(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
+    fn visit_mut_opt_ts_entity_name(
+        &mut self,
+        node: &mut Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_entity_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_entity_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_entity_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_entity_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ts_namespace_body(
+    fn visit_mut_opt_ts_namespace_body(
         &mut self,
-        node: Option<TsNamespaceBody>,
-    ) -> Option<TsNamespaceBody> {
+        node: &mut Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_namespace_body(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_namespace_body(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_namespace_body(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_namespace_body(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
+    fn visit_mut_opt_ts_type(
+        &mut self,
+        node: &mut Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
+    fn visit_mut_opt_ts_type_ann(
+        &mut self,
+        node: &mut Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_type_ann(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_type_ann(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_type_ann(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_type_ann(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_decl(
+    fn visit_mut_opt_ts_type_param_decl(
         &mut self,
-        node: Option<Box<TsTypeParamDecl>>,
-    ) -> Option<Box<TsTypeParamDecl>> {
+        node: &mut Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_type_param_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_type_param_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_type_param_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_ts_type_param_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_instantiation(
+    fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
-        node: Option<Box<TsTypeParamInstantiation>>,
-    ) -> Option<Box<TsTypeParamInstantiation>> {
+        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_opt_ts_type_param_instantiation(visitor, node)
+                VisitMutAstPath::visit_mut_opt_ts_type_param_instantiation(
+                    visitor, node, __ast_path,
+                )
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_opt_ts_type_param_instantiation(visitor, node)
+                VisitMutAstPath::visit_mut_opt_ts_type_param_instantiation(
+                    visitor, node, __ast_path,
+                )
             }
         }
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
+    fn visit_mut_opt_var_decl_or_expr(
+        &mut self,
+        node: &mut Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_var_decl_or_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_var_decl_or_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_var_decl_or_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_var_decl_or_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_vec_expr_or_spreads(
+    fn visit_mut_opt_vec_expr_or_spreads(
         &mut self,
-        node: Vec<Option<ExprOrSpread>>,
-    ) -> Vec<Option<ExprOrSpread>> {
+        node: &mut Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_vec_expr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_vec_expr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_vec_expr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_vec_expr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
+    fn visit_mut_opt_vec_pats(
+        &mut self,
+        node: &mut Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_opt_vec_pats(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_opt_vec_pats(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_opt_vec_pats(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_opt_vec_pats(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param) -> Param {
+    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_param(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
+    fn visit_mut_param_or_ts_param_prop(
+        &mut self,
+        node: &mut ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_param_or_ts_param_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_param_or_ts_param_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_param_or_ts_param_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_param_or_ts_param_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_param_or_ts_param_props(
+    fn visit_mut_param_or_ts_param_props(
         &mut self,
-        node: Vec<ParamOrTsParamProp>,
-    ) -> Vec<ParamOrTsParamProp> {
+        node: &mut Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_param_or_ts_param_props(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_param_or_ts_param_props(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_param_or_ts_param_props(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_param_or_ts_param_props(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_params(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_paren_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_paren_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_paren_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_paren_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat) -> Pat {
+    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_pats(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_pats(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_pats(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_pats(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_private_method(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_private_method(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_private_method(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_private_method(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_private_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_private_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_private_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_private_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_private_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_private_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_private_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_private_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program) -> Program {
+    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_program(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_program(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_program(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_program(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop) -> Prop {
+    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName) -> PropName {
+    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_prop_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_prop_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_prop_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_prop_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_prop_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_prop_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_prop_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_prop_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
+    fn visit_mut_prop_or_spreads(
+        &mut self,
+        node: &mut Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_prop_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_prop_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_prop_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_prop_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex) -> Regex {
+    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_regex(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_regex(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_regex(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_regex(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_rest_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_rest_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_rest_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_rest_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_return_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_return_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_return_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_return_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script) -> Script {
+    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_script(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_script(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_script(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_script(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_seq_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_seq_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_seq_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_seq_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_setter_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_setter_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_setter_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_setter_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
+    fn visit_mut_simple_assign_target(
+        &mut self,
+        node: &mut SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_simple_assign_target(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_simple_assign_target(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_simple_assign_target(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_simple_assign_target(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_span(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_spread_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_spread_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_spread_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_spread_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_static_block(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_static_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_static_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_static_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
+    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_stmts(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_stmts(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_stmts(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_stmts(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_str(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_str(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_str(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super) -> Super {
+    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_super(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_super(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_super(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_super(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_super_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_super_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_super_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_super_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
+    fn visit_mut_super_prop_expr(
+        &mut self,
+        node: &mut SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_super_prop_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_super_prop_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_super_prop_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_super_prop_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_switch_case(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_switch_case(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_switch_case(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_switch_case(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_switch_cases(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_switch_cases(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_switch_cases(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_switch_cases(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_switch_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_switch_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_switch_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_switch_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_syntax_context(
+    fn visit_mut_syntax_context(
         &mut self,
-        node: swc_common::SyntaxContext,
-    ) -> swc_common::SyntaxContext {
+        node: &mut swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_syntax_context(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_syntax_context(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_syntax_context(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_syntax_context(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_tagged_tpl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_tagged_tpl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_tagged_tpl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_tagged_tpl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_this_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_this_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_this_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_this_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_throw_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_throw_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_throw_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_throw_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
+    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_tpl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_tpl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_tpl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_tpl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_tpl_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_tpl_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_tpl_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_tpl_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_tpl_elements(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_tpl_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_tpl_elements(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_tpl_elements(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
+    fn visit_mut_true_plus_minus(
+        &mut self,
+        node: &mut TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_true_plus_minus(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_true_plus_minus(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_true_plus_minus(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_true_plus_minus(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_try_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_try_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_try_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_try_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_array_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_array_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_array_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_array_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_as_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_as_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_as_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_as_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
+    fn visit_mut_ts_call_signature_decl(
+        &mut self,
+        node: &mut TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_call_signature_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_call_signature_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_call_signature_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_call_signature_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
+    fn visit_mut_ts_conditional_type(
+        &mut self,
+        node: &mut TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_conditional_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_conditional_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_conditional_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_conditional_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
+    fn visit_mut_ts_const_assertion(
+        &mut self,
+        node: &mut TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_const_assertion(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_const_assertion(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_const_assertion(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_const_assertion(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_construct_signature_decl(
+    fn visit_mut_ts_construct_signature_decl(
         &mut self,
-        node: TsConstructSignatureDecl,
-    ) -> TsConstructSignatureDecl {
+        node: &mut TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_ts_construct_signature_decl(visitor, node)
+                VisitMutAstPath::visit_mut_ts_construct_signature_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_ts_construct_signature_decl(visitor, node)
+                VisitMutAstPath::visit_mut_ts_construct_signature_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
+    fn visit_mut_ts_constructor_type(
+        &mut self,
+        node: &mut TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_constructor_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_constructor_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_constructor_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_constructor_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_entity_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_entity_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_entity_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_entity_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_member(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_member(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_member(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_member(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
+    fn visit_mut_ts_enum_member_id(
+        &mut self,
+        node: &mut TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_member_id(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_member_id(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_member_id(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_member_id(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
+    fn visit_mut_ts_enum_members(
+        &mut self,
+        node: &mut Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_members(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_members(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_members(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_enum_members(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
+    fn visit_mut_ts_export_assignment(
+        &mut self,
+        node: &mut TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_export_assignment(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_export_assignment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_export_assignment(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_export_assignment(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
+    fn visit_mut_ts_expr_with_type_args(
+        &mut self,
+        node: &mut TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_expr_with_type_args(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_expr_with_type_args(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_expr_with_type_args(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_expr_with_type_args(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_argss(
+    fn visit_mut_ts_expr_with_type_argss(
         &mut self,
-        node: Vec<TsExprWithTypeArgs>,
-    ) -> Vec<TsExprWithTypeArgs> {
+        node: &mut Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_expr_with_type_argss(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_expr_with_type_argss(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_expr_with_type_argss(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_expr_with_type_argss(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
+    fn visit_mut_ts_external_module_ref(
+        &mut self,
+        node: &mut TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_external_module_ref(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_external_module_ref(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_external_module_ref(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_external_module_ref(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_fn_or_constructor_type(
+    fn visit_mut_ts_fn_or_constructor_type(
         &mut self,
-        node: TsFnOrConstructorType,
-    ) -> TsFnOrConstructorType {
+        node: &mut TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_or_constructor_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_fn_or_constructor_type(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_ts_fn_or_constructor_type(visitor, node)
+                VisitMutAstPath::visit_mut_ts_fn_or_constructor_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_param(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_fn_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_fn_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_fn_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_params(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_fn_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_fn_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_fn_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_fn_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_fn_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_fn_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
+    fn visit_mut_ts_getter_signature(
+        &mut self,
+        node: &mut TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_getter_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_getter_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_getter_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_getter_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
+    fn visit_mut_ts_import_equals_decl(
+        &mut self,
+        node: &mut TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_import_equals_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_import_equals_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_import_equals_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_import_equals_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_import_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_import_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_import_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_import_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
+    fn visit_mut_ts_index_signature(
+        &mut self,
+        node: &mut TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_index_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_index_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_index_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_index_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
+    fn visit_mut_ts_indexed_access_type(
+        &mut self,
+        node: &mut TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_indexed_access_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_indexed_access_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_indexed_access_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_indexed_access_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_infer_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_infer_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_infer_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_infer_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
+    fn visit_mut_ts_instantiation(
+        &mut self,
+        node: &mut TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_instantiation(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_instantiation(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_instantiation(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_instantiation(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
+    fn visit_mut_ts_interface_body(
+        &mut self,
+        node: &mut TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_interface_body(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_interface_body(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_interface_body(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_interface_body(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
+    fn visit_mut_ts_interface_decl(
+        &mut self,
+        node: &mut TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_interface_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_interface_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_interface_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_interface_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
+    fn visit_mut_ts_intersection_type(
+        &mut self,
+        node: &mut TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_intersection_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_intersection_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_intersection_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_intersection_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
+    fn visit_mut_ts_keyword_type(
+        &mut self,
+        node: &mut TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_keyword_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_keyword_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_keyword_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_keyword_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
+    fn visit_mut_ts_keyword_type_kind(
+        &mut self,
+        node: &mut TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_keyword_type_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_keyword_type_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_keyword_type_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_keyword_type_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_lit_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_lit_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_lit_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_lit_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_mapped_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_mapped_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_mapped_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_mapped_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
+    fn visit_mut_ts_method_signature(
+        &mut self,
+        node: &mut TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_method_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_method_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_method_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_method_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
+    fn visit_mut_ts_module_block(
+        &mut self,
+        node: &mut TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_block(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_ref(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_ref(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_ref(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_module_ref(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
+    fn visit_mut_ts_namespace_body(
+        &mut self,
+        node: &mut TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_namespace_body(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_namespace_body(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_namespace_body(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_namespace_body(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
+    fn visit_mut_ts_namespace_decl(
+        &mut self,
+        node: &mut TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_namespace_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_namespace_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_namespace_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_namespace_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_export_decl(
+    fn visit_mut_ts_namespace_export_decl(
         &mut self,
-        node: TsNamespaceExportDecl,
-    ) -> TsNamespaceExportDecl {
+        node: &mut TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_namespace_export_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_namespace_export_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_namespace_export_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_namespace_export_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
+    fn visit_mut_ts_non_null_expr(
+        &mut self,
+        node: &mut TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_non_null_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_non_null_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_non_null_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_non_null_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
+    fn visit_mut_ts_optional_type(
+        &mut self,
+        node: &mut TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_optional_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_optional_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_optional_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_optional_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_param_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_param_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_param_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_param_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
+    fn visit_mut_ts_param_prop_param(
+        &mut self,
+        node: &mut TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_param_prop_param(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_param_prop_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_param_prop_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_param_prop_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
+    fn visit_mut_ts_parenthesized_type(
+        &mut self,
+        node: &mut TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_parenthesized_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_parenthesized_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_parenthesized_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_parenthesized_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
+    fn visit_mut_ts_property_signature(
+        &mut self,
+        node: &mut TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_property_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_property_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_property_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_property_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
+    fn visit_mut_ts_qualified_name(
+        &mut self,
+        node: &mut TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_qualified_name(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_qualified_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_qualified_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_qualified_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_rest_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_rest_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_rest_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_rest_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
+    fn visit_mut_ts_satisfies_expr(
+        &mut self,
+        node: &mut TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_satisfies_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_satisfies_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_satisfies_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_satisfies_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
+    fn visit_mut_ts_setter_signature(
+        &mut self,
+        node: &mut TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_setter_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_setter_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_setter_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_setter_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_this_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_this_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_this_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_this_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
+    fn visit_mut_ts_this_type_or_ident(
+        &mut self,
+        node: &mut TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_this_type_or_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_this_type_or_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_this_type_or_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_this_type_or_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_tpl_lit_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_tpl_lit_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tpl_lit_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tpl_lit_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
+    fn visit_mut_ts_tuple_element(
+        &mut self,
+        node: &mut TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_tuple_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_tuple_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tuple_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tuple_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
+    fn visit_mut_ts_tuple_elements(
+        &mut self,
+        node: &mut Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_tuple_elements(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_tuple_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tuple_elements(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tuple_elements(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_tuple_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_tuple_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tuple_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_tuple_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType) -> TsType {
+    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
+    fn visit_mut_ts_type_alias_decl(
+        &mut self,
+        node: &mut TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_alias_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_alias_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_alias_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_alias_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_ann(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_ann(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_ann(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_ann(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
+    fn visit_mut_ts_type_assertion(
+        &mut self,
+        node: &mut TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_assertion(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_assertion(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_assertion(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_assertion(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
+    fn visit_mut_ts_type_element(
+        &mut self,
+        node: &mut TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_element(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
+    fn visit_mut_ts_type_elements(
+        &mut self,
+        node: &mut Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_elements(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_elements(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_elements(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
+    fn visit_mut_ts_type_operator(
+        &mut self,
+        node: &mut TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_operator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_operator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_operator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
+    fn visit_mut_ts_type_operator_op(
+        &mut self,
+        node: &mut TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_operator_op(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_operator_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_operator_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_operator_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_param(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
+    fn visit_mut_ts_type_param_decl(
+        &mut self,
+        node: &mut TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_param_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_param_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_param_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_param_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_param_instantiation(
+    fn visit_mut_ts_type_param_instantiation(
         &mut self,
-        node: TsTypeParamInstantiation,
-    ) -> TsTypeParamInstantiation {
+        node: &mut TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_ts_type_param_instantiation(visitor, node)
+                VisitMutAstPath::visit_mut_ts_type_param_instantiation(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_ts_type_param_instantiation(visitor, node)
+                VisitMutAstPath::visit_mut_ts_type_param_instantiation(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
+    fn visit_mut_ts_type_params(
+        &mut self,
+        node: &mut Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_params(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
+    fn visit_mut_ts_type_predicate(
+        &mut self,
+        node: &mut TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_predicate(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_predicate(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_predicate(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_predicate(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_query(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
+    fn visit_mut_ts_type_query_expr(
+        &mut self,
+        node: &mut TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_query_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_query_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_query_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_query_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_ref(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_ref(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_ref(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_type_ref(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_types(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_types(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_ts_union_or_intersection_type(
+    fn visit_mut_ts_union_or_intersection_type(
         &mut self,
-        node: TsUnionOrIntersectionType,
-    ) -> TsUnionOrIntersectionType {
+        node: &mut TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
             swc_visit::Either::Left(visitor) => {
-                Fold::fold_ts_union_or_intersection_type(visitor, node)
+                VisitMutAstPath::visit_mut_ts_union_or_intersection_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                Fold::fold_ts_union_or_intersection_type(visitor, node)
+                VisitMutAstPath::visit_mut_ts_union_or_intersection_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_ts_union_type(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_ts_union_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_ts_union_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_ts_union_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_unary_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_unary_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_unary_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_unary_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_unary_op(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_unary_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_unary_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_unary_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_update_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_update_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_update_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_update_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_update_op(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_update_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_update_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_update_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_using_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_using_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_using_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_using_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_var_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_var_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_var_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_var_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_var_decl_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_var_decl_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_var_decl_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_var_decl_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
+    fn visit_mut_var_decl_or_expr(
+        &mut self,
+        node: &mut VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_var_decl_or_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_var_decl_or_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_var_decl_or_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_var_decl_or_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_var_declarator(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_var_declarator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_var_declarator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_var_declarator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
+    fn visit_mut_var_declarators(
+        &mut self,
+        node: &mut Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_var_declarators(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_var_declarators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_var_declarators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_var_declarators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_while_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_while_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_while_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_while_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_with_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_with_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_with_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_with_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
         match self {
-            swc_visit::Either::Left(visitor) => Fold::fold_yield_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => Fold::fold_yield_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                VisitMutAstPath::visit_mut_yield_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                VisitMutAstPath::visit_mut_yield_expr(visitor, node, __ast_path)
+            }
         }
     }
 }
-impl<V> Fold for ::swc_visit::Optional<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> VisitMutAstPath for ::swc_visit::Optional<V>
 where
-    V: Fold,
+    V: VisitMutAstPath,
 {
     #[inline]
-    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
+    fn visit_mut_accessibility(&mut self, node: &mut Accessibility, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_accessibility(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_accessibility(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
+    fn visit_mut_array_lit(&mut self, node: &mut ArrayLit, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_array_lit(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_array_lit(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
+    fn visit_mut_array_pat(&mut self, node: &mut ArrayPat, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_array_pat(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_array_pat(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
+    fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_arrow_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_arrow_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
+    fn visit_mut_assign_expr(&mut self, node: &mut AssignExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_assign_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_assign_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
+    fn visit_mut_assign_op(&mut self, node: &mut AssignOp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_assign_op(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_assign_op(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
+    fn visit_mut_assign_pat(&mut self, node: &mut AssignPat, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_assign_pat(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_assign_pat(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
+    fn visit_mut_assign_pat_prop(
+        &mut self,
+        node: &mut AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_assign_pat_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_assign_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
+    fn visit_mut_assign_prop(&mut self, node: &mut AssignProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_assign_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_assign_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
+    fn visit_mut_assign_target(&mut self, node: &mut AssignTarget, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_assign_target(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_assign_target(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
+    fn visit_mut_assign_target_pat(
+        &mut self,
+        node: &mut AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_assign_target_pat(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_assign_target_pat(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+    fn visit_mut_atom(&mut self, node: &mut swc_atoms::Atom, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_atom(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_atom(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
+    fn visit_mut_auto_accessor(&mut self, node: &mut AutoAccessor, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_auto_accessor(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_auto_accessor(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
+    fn visit_mut_await_expr(&mut self, node: &mut AwaitExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_await_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_await_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
+    fn visit_mut_big_int(&mut self, node: &mut BigInt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_big_int(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_big_int(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
+    fn visit_mut_big_int_value(&mut self, node: &mut BigIntValue, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_big_int_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_big_int_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
+    fn visit_mut_bin_expr(&mut self, node: &mut BinExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_bin_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_bin_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
+    fn visit_mut_binary_op(&mut self, node: &mut BinaryOp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_binary_op(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_binary_op(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
+    fn visit_mut_binding_ident(&mut self, node: &mut BindingIdent, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_binding_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_binding_ident(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
+    fn visit_mut_block_stmt(&mut self, node: &mut BlockStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_block_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_block_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
+    fn visit_mut_block_stmt_or_expr(
+        &mut self,
+        node: &mut BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_block_stmt_or_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool) -> Bool {
+    fn visit_mut_bool(&mut self, node: &mut Bool, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_bool(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_bool(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
+    fn visit_mut_break_stmt(&mut self, node: &mut BreakStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_break_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_break_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
+    fn visit_mut_call_expr(&mut self, node: &mut CallExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_call_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_call_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee) -> Callee {
+    fn visit_mut_callee(&mut self, node: &mut Callee, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_callee(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_callee(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
+    fn visit_mut_catch_clause(&mut self, node: &mut CatchClause, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_catch_clause(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_catch_clause(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class) -> Class {
+    fn visit_mut_class(&mut self, node: &mut Class, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_class(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
+    fn visit_mut_class_decl(&mut self, node: &mut ClassDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_class_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
+    fn visit_mut_class_expr(&mut self, node: &mut ClassExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_class_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
+    fn visit_mut_class_member(&mut self, node: &mut ClassMember, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_class_member(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class_member(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
+    fn visit_mut_class_members(
+        &mut self,
+        node: &mut Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_class_members(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class_members(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
+    fn visit_mut_class_method(&mut self, node: &mut ClassMethod, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_class_method(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class_method(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
+    fn visit_mut_class_prop(&mut self, node: &mut ClassProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_class_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_class_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
+    fn visit_mut_computed_prop_name(
+        &mut self,
+        node: &mut ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_computed_prop_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_computed_prop_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
+    fn visit_mut_cond_expr(&mut self, node: &mut CondExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_cond_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_cond_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
+    fn visit_mut_constructor(&mut self, node: &mut Constructor, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_constructor(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_constructor(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
+    fn visit_mut_continue_stmt(&mut self, node: &mut ContinueStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_continue_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_continue_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
+    fn visit_mut_debugger_stmt(&mut self, node: &mut DebuggerStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_debugger_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_debugger_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl) -> Decl {
+    fn visit_mut_decl(&mut self, node: &mut Decl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
+    fn visit_mut_decorator(&mut self, node: &mut Decorator, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_decorator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_decorator(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
+    fn visit_mut_decorators(&mut self, node: &mut Vec<Decorator>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_decorators(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_decorators(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
+    fn visit_mut_default_decl(&mut self, node: &mut DefaultDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_default_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_default_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
+    fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_do_while_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_do_while_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
+    fn visit_mut_empty_stmt(&mut self, node: &mut EmptyStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_empty_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_empty_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
+    fn visit_mut_es_version(&mut self, node: &mut EsVersion, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_es_version(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_es_version(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
+    fn visit_mut_export_all(&mut self, node: &mut ExportAll, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_export_all(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_all(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
+    fn visit_mut_export_decl(&mut self, node: &mut ExportDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_export_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
+    fn visit_mut_export_default_decl(
+        &mut self,
+        node: &mut ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_export_default_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_default_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
+    fn visit_mut_export_default_expr(
+        &mut self,
+        node: &mut ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_export_default_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_default_expr(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_default_specifier(
+    fn visit_mut_export_default_specifier(
         &mut self,
-        node: ExportDefaultSpecifier,
-    ) -> ExportDefaultSpecifier {
+        node: &mut ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_export_default_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_default_specifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
+    fn visit_mut_export_named_specifier(
+        &mut self,
+        node: &mut ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_export_named_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_named_specifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_namespace_specifier(
+    fn visit_mut_export_namespace_specifier(
         &mut self,
-        node: ExportNamespaceSpecifier,
-    ) -> ExportNamespaceSpecifier {
+        node: &mut ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_export_namespace_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
+    fn visit_mut_export_specifier(
+        &mut self,
+        node: &mut ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_export_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_specifier(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
+    fn visit_mut_export_specifiers(
+        &mut self,
+        node: &mut Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_export_specifiers(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_export_specifiers(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr) -> Expr {
+    fn visit_mut_expr(&mut self, node: &mut Expr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
+    fn visit_mut_expr_or_spread(&mut self, node: &mut ExprOrSpread, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_expr_or_spread(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_expr_or_spread(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
+    fn visit_mut_expr_or_spreads(
+        &mut self,
+        node: &mut Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_expr_or_spreads(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_expr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
+    fn visit_mut_expr_stmt(&mut self, node: &mut ExprStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_expr_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_expr_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
+    fn visit_mut_exprs(&mut self, node: &mut Vec<Box<Expr>>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_exprs(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_exprs(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
+    fn visit_mut_fn_decl(&mut self, node: &mut FnDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_fn_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_fn_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
+    fn visit_mut_fn_expr(&mut self, node: &mut FnExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_fn_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_fn_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
+    fn visit_mut_for_head(&mut self, node: &mut ForHead, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_for_head(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_for_head(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
+    fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_for_in_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_for_in_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
+    fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_for_of_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_for_of_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
+    fn visit_mut_for_stmt(&mut self, node: &mut ForStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_for_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_for_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function) -> Function {
+    fn visit_mut_function(&mut self, node: &mut Function, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_function(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_function(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
+    fn visit_mut_getter_prop(&mut self, node: &mut GetterProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_getter_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_getter_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident) -> Ident {
+    fn visit_mut_ident(&mut self, node: &mut Ident, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ident(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
+    fn visit_mut_ident_name(&mut self, node: &mut IdentName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ident_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ident_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
+    fn visit_mut_if_stmt(&mut self, node: &mut IfStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_if_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_if_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import) -> Import {
+    fn visit_mut_import(&mut self, node: &mut Import, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_import(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
+    fn visit_mut_import_decl(&mut self, node: &mut ImportDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_import_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_default_specifier(
+    fn visit_mut_import_default_specifier(
         &mut self,
-        node: ImportDefaultSpecifier,
-    ) -> ImportDefaultSpecifier {
+        node: &mut ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_default_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_default_specifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
+    fn visit_mut_import_named_specifier(
+        &mut self,
+        node: &mut ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_named_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_named_specifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
+    fn visit_mut_import_phase(&mut self, node: &mut ImportPhase, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_import_phase(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_phase(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
+    fn visit_mut_import_specifier(
+        &mut self,
+        node: &mut ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_specifier(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
+    fn visit_mut_import_specifiers(
+        &mut self,
+        node: &mut Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_specifiers(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_specifiers(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_star_as_specifier(
+    fn visit_mut_import_star_as_specifier(
         &mut self,
-        node: ImportStarAsSpecifier,
-    ) -> ImportStarAsSpecifier {
+        node: &mut ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_star_as_specifier(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
+    fn visit_mut_import_with(&mut self, node: &mut ImportWith, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_import_with(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_with(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
+    fn visit_mut_import_with_item(
+        &mut self,
+        node: &mut ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_with_item(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_with_item(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
+    fn visit_mut_import_with_items(
+        &mut self,
+        node: &mut Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_import_with_items(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_import_with_items(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
+    fn visit_mut_invalid(&mut self, node: &mut Invalid, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_invalid(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_invalid(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
+    fn visit_mut_jsx_attr(&mut self, node: &mut JSXAttr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_attr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_attr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
+    fn visit_mut_jsx_attr_name(&mut self, node: &mut JSXAttrName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_attr_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_attr_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
+    fn visit_mut_jsx_attr_or_spread(
+        &mut self,
+        node: &mut JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_attr_or_spread(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
+    fn visit_mut_jsx_attr_or_spreads(
+        &mut self,
+        node: &mut Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_attr_or_spreads(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
+    fn visit_mut_jsx_attr_value(&mut self, node: &mut JSXAttrValue, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_attr_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_attr_value(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
+    fn visit_mut_jsx_closing_element(
+        &mut self,
+        node: &mut JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_closing_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_closing_element(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
+    fn visit_mut_jsx_closing_fragment(
+        &mut self,
+        node: &mut JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_closing_fragment(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
+    fn visit_mut_jsx_element(&mut self, node: &mut JSXElement, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_element(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
+    fn visit_mut_jsx_element_child(
+        &mut self,
+        node: &mut JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_element_child(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_element_child(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
+    fn visit_mut_jsx_element_childs(
+        &mut self,
+        node: &mut Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_element_childs(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_element_childs(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
+    fn visit_mut_jsx_element_name(
+        &mut self,
+        node: &mut JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_element_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_element_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
+    fn visit_mut_jsx_empty_expr(&mut self, node: &mut JSXEmptyExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_empty_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
+    fn visit_mut_jsx_expr(&mut self, node: &mut JSXExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
+    fn visit_mut_jsx_expr_container(
+        &mut self,
+        node: &mut JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_expr_container(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_expr_container(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
+    fn visit_mut_jsx_fragment(&mut self, node: &mut JSXFragment, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_fragment(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_fragment(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
+    fn visit_mut_jsx_member_expr(
+        &mut self,
+        node: &mut JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_member_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_member_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
+    fn visit_mut_jsx_namespaced_name(
+        &mut self,
+        node: &mut JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_namespaced_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
+    fn visit_mut_jsx_object(&mut self, node: &mut JSXObject, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_object(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_object(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
+    fn visit_mut_jsx_opening_element(
+        &mut self,
+        node: &mut JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_opening_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_opening_element(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
+    fn visit_mut_jsx_opening_fragment(
+        &mut self,
+        node: &mut JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_opening_fragment(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
+    fn visit_mut_jsx_spread_child(
+        &mut self,
+        node: &mut JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_jsx_spread_child(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_spread_child(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
+    fn visit_mut_jsx_text(&mut self, node: &mut JSXText, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_jsx_text(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_jsx_text(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key) -> Key {
+    fn visit_mut_key(&mut self, node: &mut Key, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_key(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_key(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
+    fn visit_mut_key_value_pat_prop(
+        &mut self,
+        node: &mut KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_key_value_pat_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
+    fn visit_mut_key_value_prop(&mut self, node: &mut KeyValueProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_key_value_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_key_value_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
+    fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_labeled_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_labeled_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit) -> Lit {
+    fn visit_mut_lit(&mut self, node: &mut Lit, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_lit(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_lit(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
+    fn visit_mut_member_expr(&mut self, node: &mut MemberExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_member_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_member_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
+    fn visit_mut_member_prop(&mut self, node: &mut MemberProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_member_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_member_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
+    fn visit_mut_meta_prop_expr(&mut self, node: &mut MetaPropExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_meta_prop_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_meta_prop_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
+    fn visit_mut_meta_prop_kind(&mut self, node: &mut MetaPropKind, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_meta_prop_kind(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_meta_prop_kind(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
+    fn visit_mut_method_kind(&mut self, node: &mut MethodKind, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_method_kind(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_method_kind(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
+    fn visit_mut_method_prop(&mut self, node: &mut MethodProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_method_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_method_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module) -> Module {
+    fn visit_mut_module(&mut self, node: &mut Module, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_module(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_module(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
+    fn visit_mut_module_decl(&mut self, node: &mut ModuleDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_module_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_module_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
+    fn visit_mut_module_export_name(
+        &mut self,
+        node: &mut ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_module_export_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_module_export_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
+    fn visit_mut_module_item(&mut self, node: &mut ModuleItem, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_module_item(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_module_item(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
+    fn visit_mut_module_items(&mut self, node: &mut Vec<ModuleItem>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_module_items(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_module_items(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
+    fn visit_mut_named_export(&mut self, node: &mut NamedExport, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_named_export(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_named_export(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
+    fn visit_mut_new_expr(&mut self, node: &mut NewExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_new_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_new_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null) -> Null {
+    fn visit_mut_null(&mut self, node: &mut Null, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_null(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_null(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number) -> Number {
+    fn visit_mut_number(&mut self, node: &mut Number, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_number(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_number(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
+    fn visit_mut_object_lit(&mut self, node: &mut ObjectLit, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_object_lit(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_object_lit(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
+    fn visit_mut_object_pat(&mut self, node: &mut ObjectPat, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_object_pat(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_object_pat(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
+    fn visit_mut_object_pat_prop(
+        &mut self,
+        node: &mut ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_object_pat_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_object_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
+    fn visit_mut_object_pat_props(
+        &mut self,
+        node: &mut Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_object_pat_props(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_object_pat_props(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
+    fn visit_mut_opt_accessibility(
+        &mut self,
+        node: &mut Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_accessibility(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_accessibility(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+    fn visit_mut_opt_atom(
+        &mut self,
+        node: &mut Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_atom(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_atom(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
+    fn visit_mut_opt_block_stmt(
+        &mut self,
+        node: &mut Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_block_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_block_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
+    fn visit_mut_opt_call(&mut self, node: &mut OptCall, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_call(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_call(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
+    fn visit_mut_opt_catch_clause(
+        &mut self,
+        node: &mut Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_catch_clause(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_catch_clause(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
+    fn visit_mut_opt_chain_base(&mut self, node: &mut OptChainBase, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_chain_base(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_chain_base(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
+    fn visit_mut_opt_chain_expr(&mut self, node: &mut OptChainExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_chain_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_chain_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
+    fn visit_mut_opt_expr(&mut self, node: &mut Option<Box<Expr>>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
+    fn visit_mut_opt_expr_or_spread(
+        &mut self,
+        node: &mut Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_expr_or_spread(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_expr_or_spreads(
+    fn visit_mut_opt_expr_or_spreads(
         &mut self,
-        node: Option<Vec<ExprOrSpread>>,
-    ) -> Option<Vec<ExprOrSpread>> {
+        node: &mut Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_expr_or_spreads(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+    fn visit_mut_opt_ident(&mut self, node: &mut Option<Ident>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ident(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
+    fn visit_mut_opt_jsx_attr_value(
+        &mut self,
+        node: &mut Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_jsx_attr_value(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_jsx_closing_element(
+    fn visit_mut_opt_jsx_closing_element(
         &mut self,
-        node: Option<JSXClosingElement>,
-    ) -> Option<JSXClosingElement> {
+        node: &mut Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_jsx_closing_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_module_export_name(
+    fn visit_mut_opt_module_export_name(
         &mut self,
-        node: Option<ModuleExportName>,
-    ) -> Option<ModuleExportName> {
+        node: &mut Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_module_export_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_module_export_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
+    fn visit_mut_opt_object_lit(
+        &mut self,
+        node: &mut Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_object_lit(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_object_lit(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
+    fn visit_mut_opt_pat(&mut self, node: &mut Option<Pat>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_pat(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_pat(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
+    fn visit_mut_opt_span(
+        &mut self,
+        node: &mut Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_span(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_span(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
+    fn visit_mut_opt_stmt(&mut self, node: &mut Option<Box<Stmt>>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
+    fn visit_mut_opt_str(&mut self, node: &mut Option<Box<Str>>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_opt_str(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_str(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
+    fn visit_mut_opt_true_plus_minus(
+        &mut self,
+        node: &mut Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_true_plus_minus(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
+    fn visit_mut_opt_ts_entity_name(
+        &mut self,
+        node: &mut Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_ts_entity_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_namespace_body(
+    fn visit_mut_opt_ts_namespace_body(
         &mut self,
-        node: Option<TsNamespaceBody>,
-    ) -> Option<TsNamespaceBody> {
+        node: &mut Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_ts_namespace_body(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
+    fn visit_mut_opt_ts_type(
+        &mut self,
+        node: &mut Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_ts_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ts_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
+    fn visit_mut_opt_ts_type_ann(
+        &mut self,
+        node: &mut Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_ts_type_ann(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_decl(
+    fn visit_mut_opt_ts_type_param_decl(
         &mut self,
-        node: Option<Box<TsTypeParamDecl>>,
-    ) -> Option<Box<TsTypeParamDecl>> {
+        node: &mut Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_ts_type_param_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_param_instantiation(
+    fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
-        node: Option<Box<TsTypeParamInstantiation>>,
-    ) -> Option<Box<TsTypeParamInstantiation>> {
+        node: &mut Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_ts_type_param_instantiation(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
+    fn visit_mut_opt_var_decl_or_expr(
+        &mut self,
+        node: &mut Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_var_decl_or_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_vec_expr_or_spreads(
+    fn visit_mut_opt_vec_expr_or_spreads(
         &mut self,
-        node: Vec<Option<ExprOrSpread>>,
-    ) -> Vec<Option<ExprOrSpread>> {
+        node: &mut Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_vec_expr_or_spreads(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
+    fn visit_mut_opt_vec_pats(
+        &mut self,
+        node: &mut Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_opt_vec_pats(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_opt_vec_pats(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param) -> Param {
+    fn visit_mut_param(&mut self, node: &mut Param, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_param(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_param(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
+    fn visit_mut_param_or_ts_param_prop(
+        &mut self,
+        node: &mut ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_param_or_ts_param_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_param_or_ts_param_props(
+    fn visit_mut_param_or_ts_param_props(
         &mut self,
-        node: Vec<ParamOrTsParamProp>,
-    ) -> Vec<ParamOrTsParamProp> {
+        node: &mut Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_param_or_ts_param_props(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
+    fn visit_mut_params(&mut self, node: &mut Vec<Param>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_params(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_params(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
+    fn visit_mut_paren_expr(&mut self, node: &mut ParenExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_paren_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_paren_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat) -> Pat {
+    fn visit_mut_pat(&mut self, node: &mut Pat, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_pat(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pat(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
+    fn visit_mut_pats(&mut self, node: &mut Vec<Pat>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_pats(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_pats(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
+    fn visit_mut_private_method(&mut self, node: &mut PrivateMethod, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_private_method(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_private_method(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
+    fn visit_mut_private_name(&mut self, node: &mut PrivateName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_private_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_private_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
+    fn visit_mut_private_prop(&mut self, node: &mut PrivateProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_private_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_private_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program) -> Program {
+    fn visit_mut_program(&mut self, node: &mut Program, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_program(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_program(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop) -> Prop {
+    fn visit_mut_prop(&mut self, node: &mut Prop, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName) -> PropName {
+    fn visit_mut_prop_name(&mut self, node: &mut PropName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_prop_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_prop_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
+    fn visit_mut_prop_or_spread(&mut self, node: &mut PropOrSpread, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_prop_or_spread(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_prop_or_spread(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
+    fn visit_mut_prop_or_spreads(
+        &mut self,
+        node: &mut Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_prop_or_spreads(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_prop_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex) -> Regex {
+    fn visit_mut_regex(&mut self, node: &mut Regex, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_regex(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_regex(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
+    fn visit_mut_rest_pat(&mut self, node: &mut RestPat, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_rest_pat(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_rest_pat(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
+    fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_return_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_return_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script) -> Script {
+    fn visit_mut_script(&mut self, node: &mut Script, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_script(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_script(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
+    fn visit_mut_seq_expr(&mut self, node: &mut SeqExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_seq_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_seq_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
+    fn visit_mut_setter_prop(&mut self, node: &mut SetterProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_setter_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_setter_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
+    fn visit_mut_simple_assign_target(
+        &mut self,
+        node: &mut SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_simple_assign_target(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_simple_assign_target(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+    fn visit_mut_span(&mut self, node: &mut swc_common::Span, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_span(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_span(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
+    fn visit_mut_spread_element(&mut self, node: &mut SpreadElement, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_spread_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_spread_element(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
+    fn visit_mut_static_block(&mut self, node: &mut StaticBlock, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_static_block(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_static_block(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
+    fn visit_mut_stmt(&mut self, node: &mut Stmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
+    fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_stmts(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_stmts(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str) -> Str {
+    fn visit_mut_str(&mut self, node: &mut Str, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_str(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_str(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super) -> Super {
+    fn visit_mut_super(&mut self, node: &mut Super, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_super(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_super(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
+    fn visit_mut_super_prop(&mut self, node: &mut SuperProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_super_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_super_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
+    fn visit_mut_super_prop_expr(
+        &mut self,
+        node: &mut SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_super_prop_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_super_prop_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
+    fn visit_mut_switch_case(&mut self, node: &mut SwitchCase, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_switch_case(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_switch_case(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
+    fn visit_mut_switch_cases(&mut self, node: &mut Vec<SwitchCase>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_switch_cases(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_switch_cases(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
+    fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_switch_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_switch_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_syntax_context(
+    fn visit_mut_syntax_context(
         &mut self,
-        node: swc_common::SyntaxContext,
-    ) -> swc_common::SyntaxContext {
+        node: &mut swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_syntax_context(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_syntax_context(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
+    fn visit_mut_tagged_tpl(&mut self, node: &mut TaggedTpl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_tagged_tpl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_tagged_tpl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
+    fn visit_mut_this_expr(&mut self, node: &mut ThisExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_this_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_this_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
+    fn visit_mut_throw_stmt(&mut self, node: &mut ThrowStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_throw_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_throw_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
+    fn visit_mut_tpl(&mut self, node: &mut Tpl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_tpl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_tpl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
+    fn visit_mut_tpl_element(&mut self, node: &mut TplElement, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_tpl_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_tpl_element(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
+    fn visit_mut_tpl_elements(&mut self, node: &mut Vec<TplElement>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_tpl_elements(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_tpl_elements(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
+    fn visit_mut_true_plus_minus(
+        &mut self,
+        node: &mut TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_true_plus_minus(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_true_plus_minus(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
+    fn visit_mut_try_stmt(&mut self, node: &mut TryStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_try_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_try_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
+    fn visit_mut_ts_array_type(&mut self, node: &mut TsArrayType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_array_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_array_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
+    fn visit_mut_ts_as_expr(&mut self, node: &mut TsAsExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_as_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_as_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
+    fn visit_mut_ts_call_signature_decl(
+        &mut self,
+        node: &mut TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_call_signature_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
+    fn visit_mut_ts_conditional_type(
+        &mut self,
+        node: &mut TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_conditional_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_conditional_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
+    fn visit_mut_ts_const_assertion(
+        &mut self,
+        node: &mut TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_const_assertion(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_const_assertion(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_construct_signature_decl(
+    fn visit_mut_ts_construct_signature_decl(
         &mut self,
-        node: TsConstructSignatureDecl,
-    ) -> TsConstructSignatureDecl {
+        node: &mut TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_construct_signature_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
+    fn visit_mut_ts_constructor_type(
+        &mut self,
+        node: &mut TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_constructor_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_constructor_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
+    fn visit_mut_ts_entity_name(&mut self, node: &mut TsEntityName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_entity_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_entity_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
+    fn visit_mut_ts_enum_decl(&mut self, node: &mut TsEnumDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_enum_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_enum_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
+    fn visit_mut_ts_enum_member(&mut self, node: &mut TsEnumMember, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_enum_member(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_enum_member(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
+    fn visit_mut_ts_enum_member_id(
+        &mut self,
+        node: &mut TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_enum_member_id(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
+    fn visit_mut_ts_enum_members(
+        &mut self,
+        node: &mut Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_enum_members(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_enum_members(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
+    fn visit_mut_ts_export_assignment(
+        &mut self,
+        node: &mut TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_export_assignment(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_export_assignment(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
+    fn visit_mut_ts_expr_with_type_args(
+        &mut self,
+        node: &mut TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_expr_with_type_args(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_argss(
+    fn visit_mut_ts_expr_with_type_argss(
         &mut self,
-        node: Vec<TsExprWithTypeArgs>,
-    ) -> Vec<TsExprWithTypeArgs> {
+        node: &mut Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_expr_with_type_argss(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
+    fn visit_mut_ts_external_module_ref(
+        &mut self,
+        node: &mut TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_external_module_ref(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_fn_or_constructor_type(
+    fn visit_mut_ts_fn_or_constructor_type(
         &mut self,
-        node: TsFnOrConstructorType,
-    ) -> TsFnOrConstructorType {
+        node: &mut TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_fn_or_constructor_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
+    fn visit_mut_ts_fn_param(&mut self, node: &mut TsFnParam, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_fn_param(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_fn_param(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
+    fn visit_mut_ts_fn_params(&mut self, node: &mut Vec<TsFnParam>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_fn_params(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_fn_params(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
+    fn visit_mut_ts_fn_type(&mut self, node: &mut TsFnType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_fn_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_fn_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
+    fn visit_mut_ts_getter_signature(
+        &mut self,
+        node: &mut TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_getter_signature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_getter_signature(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
+    fn visit_mut_ts_import_equals_decl(
+        &mut self,
+        node: &mut TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_import_equals_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
+    fn visit_mut_ts_import_type(&mut self, node: &mut TsImportType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_import_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_import_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
+    fn visit_mut_ts_index_signature(
+        &mut self,
+        node: &mut TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_index_signature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_index_signature(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
+    fn visit_mut_ts_indexed_access_type(
+        &mut self,
+        node: &mut TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_indexed_access_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
+    fn visit_mut_ts_infer_type(&mut self, node: &mut TsInferType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_infer_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_infer_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
+    fn visit_mut_ts_instantiation(
+        &mut self,
+        node: &mut TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_instantiation(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_instantiation(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
+    fn visit_mut_ts_interface_body(
+        &mut self,
+        node: &mut TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_interface_body(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_interface_body(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
+    fn visit_mut_ts_interface_decl(
+        &mut self,
+        node: &mut TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_interface_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_interface_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
+    fn visit_mut_ts_intersection_type(
+        &mut self,
+        node: &mut TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_intersection_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_intersection_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
+    fn visit_mut_ts_keyword_type(
+        &mut self,
+        node: &mut TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_keyword_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_keyword_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
+    fn visit_mut_ts_keyword_type_kind(
+        &mut self,
+        node: &mut TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_keyword_type_kind(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
+    fn visit_mut_ts_lit(&mut self, node: &mut TsLit, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_lit(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_lit(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
+    fn visit_mut_ts_lit_type(&mut self, node: &mut TsLitType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_lit_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_lit_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
+    fn visit_mut_ts_mapped_type(&mut self, node: &mut TsMappedType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_mapped_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_mapped_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
+    fn visit_mut_ts_method_signature(
+        &mut self,
+        node: &mut TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_method_signature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_method_signature(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
+    fn visit_mut_ts_module_block(
+        &mut self,
+        node: &mut TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_module_block(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_module_block(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
+    fn visit_mut_ts_module_decl(&mut self, node: &mut TsModuleDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_module_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_module_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
+    fn visit_mut_ts_module_name(&mut self, node: &mut TsModuleName, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_module_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_module_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
+    fn visit_mut_ts_module_ref(&mut self, node: &mut TsModuleRef, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_module_ref(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_module_ref(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
+    fn visit_mut_ts_namespace_body(
+        &mut self,
+        node: &mut TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_namespace_body(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_namespace_body(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
+    fn visit_mut_ts_namespace_decl(
+        &mut self,
+        node: &mut TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_namespace_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_export_decl(
+    fn visit_mut_ts_namespace_export_decl(
         &mut self,
-        node: TsNamespaceExportDecl,
-    ) -> TsNamespaceExportDecl {
+        node: &mut TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_namespace_export_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
+    fn visit_mut_ts_non_null_expr(
+        &mut self,
+        node: &mut TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_non_null_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
+    fn visit_mut_ts_optional_type(
+        &mut self,
+        node: &mut TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_optional_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_optional_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
+    fn visit_mut_ts_param_prop(&mut self, node: &mut TsParamProp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_param_prop(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_param_prop(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
+    fn visit_mut_ts_param_prop_param(
+        &mut self,
+        node: &mut TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_param_prop_param(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
+    fn visit_mut_ts_parenthesized_type(
+        &mut self,
+        node: &mut TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_parenthesized_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
+    fn visit_mut_ts_property_signature(
+        &mut self,
+        node: &mut TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_property_signature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_property_signature(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
+    fn visit_mut_ts_qualified_name(
+        &mut self,
+        node: &mut TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_qualified_name(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_qualified_name(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
+    fn visit_mut_ts_rest_type(&mut self, node: &mut TsRestType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_rest_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_rest_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
+    fn visit_mut_ts_satisfies_expr(
+        &mut self,
+        node: &mut TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_satisfies_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
+    fn visit_mut_ts_setter_signature(
+        &mut self,
+        node: &mut TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_setter_signature(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_setter_signature(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
+    fn visit_mut_ts_this_type(&mut self, node: &mut TsThisType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_this_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_this_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
+    fn visit_mut_ts_this_type_or_ident(
+        &mut self,
+        node: &mut TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_this_type_or_ident(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
+    fn visit_mut_ts_tpl_lit_type(&mut self, node: &mut TsTplLitType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_tpl_lit_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
+    fn visit_mut_ts_tuple_element(
+        &mut self,
+        node: &mut TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_tuple_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_tuple_element(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
+    fn visit_mut_ts_tuple_elements(
+        &mut self,
+        node: &mut Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_tuple_elements(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
+    fn visit_mut_ts_tuple_type(&mut self, node: &mut TsTupleType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_tuple_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_tuple_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType) -> TsType {
+    fn visit_mut_ts_type(&mut self, node: &mut TsType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
+    fn visit_mut_ts_type_alias_decl(
+        &mut self,
+        node: &mut TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_alias_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
+    fn visit_mut_ts_type_ann(&mut self, node: &mut TsTypeAnn, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_ann(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_ann(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
+    fn visit_mut_ts_type_assertion(
+        &mut self,
+        node: &mut TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_assertion(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_assertion(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
+    fn visit_mut_ts_type_element(
+        &mut self,
+        node: &mut TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_element(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_element(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
+    fn visit_mut_ts_type_elements(
+        &mut self,
+        node: &mut Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_elements(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_elements(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
+    fn visit_mut_ts_type_lit(&mut self, node: &mut TsTypeLit, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_lit(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_lit(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
+    fn visit_mut_ts_type_operator(
+        &mut self,
+        node: &mut TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_operator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_operator(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
+    fn visit_mut_ts_type_operator_op(
+        &mut self,
+        node: &mut TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_operator_op(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
+    fn visit_mut_ts_type_param(&mut self, node: &mut TsTypeParam, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_param(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_param(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
+    fn visit_mut_ts_type_param_decl(
+        &mut self,
+        node: &mut TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_param_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_param_instantiation(
+    fn visit_mut_ts_type_param_instantiation(
         &mut self,
-        node: TsTypeParamInstantiation,
-    ) -> TsTypeParamInstantiation {
+        node: &mut TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_param_instantiation(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
+    fn visit_mut_ts_type_params(
+        &mut self,
+        node: &mut Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_params(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_params(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
+    fn visit_mut_ts_type_predicate(
+        &mut self,
+        node: &mut TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_predicate(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_predicate(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
+    fn visit_mut_ts_type_query(&mut self, node: &mut TsTypeQuery, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_query(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_query(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
+    fn visit_mut_ts_type_query_expr(
+        &mut self,
+        node: &mut TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_query_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
+    fn visit_mut_ts_type_ref(&mut self, node: &mut TsTypeRef, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_type_ref(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_type_ref(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
+    fn visit_mut_ts_types(&mut self, node: &mut Vec<Box<TsType>>, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_types(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_types(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_union_or_intersection_type(
+    fn visit_mut_ts_union_or_intersection_type(
         &mut self,
-        node: TsUnionOrIntersectionType,
-    ) -> TsUnionOrIntersectionType {
+        node: &mut TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_ts_union_or_intersection_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
+    fn visit_mut_ts_union_type(&mut self, node: &mut TsUnionType, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_ts_union_type(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_ts_union_type(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
+    fn visit_mut_unary_expr(&mut self, node: &mut UnaryExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_unary_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_unary_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
+    fn visit_mut_unary_op(&mut self, node: &mut UnaryOp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_unary_op(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_unary_op(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
+    fn visit_mut_update_expr(&mut self, node: &mut UpdateExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_update_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_update_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
+    fn visit_mut_update_op(&mut self, node: &mut UpdateOp, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_update_op(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_update_op(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
+    fn visit_mut_using_decl(&mut self, node: &mut UsingDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_using_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_using_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
+    fn visit_mut_var_decl(&mut self, node: &mut VarDecl, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_var_decl(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_var_decl(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
+    fn visit_mut_var_decl_kind(&mut self, node: &mut VarDeclKind, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_var_decl_kind(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_var_decl_kind(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
+    fn visit_mut_var_decl_or_expr(
+        &mut self,
+        node: &mut VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_var_decl_or_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
+    fn visit_mut_var_declarator(&mut self, node: &mut VarDeclarator, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_var_declarator(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_var_declarator(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
+    fn visit_mut_var_declarators(
+        &mut self,
+        node: &mut Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) {
         if self.enabled {
-            <V as Fold>::fold_var_declarators(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_var_declarators(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
+    fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_while_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_while_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
+    fn visit_mut_with_stmt(&mut self, node: &mut WithStmt, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_with_stmt(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_with_stmt(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
+    fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr, __ast_path: &mut AstKindPath) {
         if self.enabled {
-            <V as Fold>::fold_yield_expr(&mut self.visitor, node)
+            <V as VisitMutAstPath>::visit_mut_yield_expr(&mut self.visitor, node, __ast_path)
         } else {
-            node
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait FoldWith<V: ?Sized + Fold> {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait VisitMutWithAstPath<V: ?Sized + VisitMutAstPath> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn fold_with(self, visitor: &mut V) -> Self;
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn fold_children_with(self, visitor: &mut V) -> Self;
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath);
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Accessibility {
-    #[doc = "Calls [Fold`::fold_accessibility`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_accessibility(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Accessibility {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_accessibility`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_accessibility(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            Accessibility::Public => Accessibility::Public,
-            Accessibility::Protected => Accessibility::Protected,
-            Accessibility::Private => Accessibility::Private,
+            Accessibility::Public => {}
+            Accessibility::Protected => {}
+            Accessibility::Private => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ArrayLit {
-    #[doc = "Calls [Fold`::fold_array_lit`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_array_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrayLit {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_array_lit`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_array_lit(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ArrayLit { span, elems } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let elems =
-                    { <Vec<Option<ExprOrSpread>> as FoldWith<V>>::fold_with(elems, visitor) };
-                ArrayLit { span, elems }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrayLit(self::fields::ArrayLitField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayLit(
+                        self::fields::ArrayLitField::Elems(usize::MAX),
+                    ));
+                    <Vec<Option<ExprOrSpread>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        elems,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ArrayPat {
-    #[doc = "Calls [Fold`::fold_array_pat`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_array_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrayPat {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_array_pat`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_array_pat(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ArrayPat {
                 span,
@@ -103359,27 +79145,48 @@ impl<V: ?Sized + Fold> FoldWith<V> for ArrayPat {
                 optional,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let elems = { <Vec<Option<Pat>> as FoldWith<V>>::fold_with(elems, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                ArrayPat {
-                    span,
-                    elems,
-                    optional,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrayPat(self::fields::ArrayPatField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
+                        self::fields::ArrayPatField::Elems(usize::MAX),
+                    ));
+                    <Vec<Option<Pat>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        elems,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
+                        self::fields::ArrayPatField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ArrowExpr {
-    #[doc = "Calls [Fold`::fold_arrow_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_arrow_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ArrowExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_arrow_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_arrow_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ArrowExpr {
                 span,
@@ -103391,36 +79198,72 @@ impl<V: ?Sized + Fold> FoldWith<V> for ArrowExpr {
                 type_params,
                 return_type,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let params = { <Vec<Pat> as FoldWith<V>>::fold_with(params, visitor) };
-                let body = { <Box<BlockStmtOrExpr> as FoldWith<V>>::fold_with(body, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
+                        self::fields::ArrowExprField::Params(usize::MAX),
+                    ));
+                    <Vec<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Body));
+                    <Box<BlockStmtOrExpr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
+                        self::fields::ArrowExprField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
+                        self::fields::ArrowExprField::ReturnType,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        return_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let return_type =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(return_type, visitor) };
-                ArrowExpr {
-                    span,
-                    ctxt,
-                    params,
-                    body,
-                    is_async,
-                    is_generator,
-                    type_params,
-                    return_type,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AssignExpr {
-    #[doc = "Calls [Fold`::fold_assign_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_assign_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AssignExpr {
                 span,
@@ -103428,147 +79271,296 @@ impl<V: ?Sized + Fold> FoldWith<V> for AssignExpr {
                 left,
                 right,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let op = { <AssignOp as FoldWith<V>>::fold_with(op, visitor) };
-                let left = { <AssignTarget as FoldWith<V>>::fold_with(left, visitor) };
-                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
-                AssignExpr {
-                    span,
-                    op,
-                    left,
-                    right,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
+                        self::fields::AssignExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AssignExpr(self::fields::AssignExprField::Op));
+                    <AssignOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
+                        self::fields::AssignExprField::Left,
+                    ));
+                    <AssignTarget as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
+                        self::fields::AssignExprField::Right,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AssignOp {
-    #[doc = "Calls [Fold`::fold_assign_op`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_assign_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignOp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_op`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_op(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            AssignOp::Assign => AssignOp::Assign,
-            AssignOp::AddAssign => AssignOp::AddAssign,
-            AssignOp::SubAssign => AssignOp::SubAssign,
-            AssignOp::MulAssign => AssignOp::MulAssign,
-            AssignOp::DivAssign => AssignOp::DivAssign,
-            AssignOp::ModAssign => AssignOp::ModAssign,
-            AssignOp::LShiftAssign => AssignOp::LShiftAssign,
-            AssignOp::RShiftAssign => AssignOp::RShiftAssign,
-            AssignOp::ZeroFillRShiftAssign => AssignOp::ZeroFillRShiftAssign,
-            AssignOp::BitOrAssign => AssignOp::BitOrAssign,
-            AssignOp::BitXorAssign => AssignOp::BitXorAssign,
-            AssignOp::BitAndAssign => AssignOp::BitAndAssign,
-            AssignOp::ExpAssign => AssignOp::ExpAssign,
-            AssignOp::AndAssign => AssignOp::AndAssign,
-            AssignOp::OrAssign => AssignOp::OrAssign,
-            AssignOp::NullishAssign => AssignOp::NullishAssign,
+            AssignOp::Assign => {}
+            AssignOp::AddAssign => {}
+            AssignOp::SubAssign => {}
+            AssignOp::MulAssign => {}
+            AssignOp::DivAssign => {}
+            AssignOp::ModAssign => {}
+            AssignOp::LShiftAssign => {}
+            AssignOp::RShiftAssign => {}
+            AssignOp::ZeroFillRShiftAssign => {}
+            AssignOp::BitOrAssign => {}
+            AssignOp::BitXorAssign => {}
+            AssignOp::BitAndAssign => {}
+            AssignOp::ExpAssign => {}
+            AssignOp::AndAssign => {}
+            AssignOp::OrAssign => {}
+            AssignOp::NullishAssign => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AssignPat {
-    #[doc = "Calls [Fold`::fold_assign_pat`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_assign_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignPat {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_pat`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_pat(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AssignPat { span, left, right } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <Box<Pat> as FoldWith<V>>::fold_with(left, visitor) };
-                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
-                AssignPat { span, left, right }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Left));
+                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPat(
+                        self::fields::AssignPatField::Right,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AssignPatProp {
-    #[doc = "Calls [Fold`::fold_assign_pat_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_assign_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignPatProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_pat_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_pat_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AssignPatProp { span, key, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <BindingIdent as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
-                AssignPatProp { span, key, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
+                        self::fields::AssignPatPropField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
+                        self::fields::AssignPatPropField::Key,
+                    ));
+                    <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
+                        self::fields::AssignPatPropField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AssignProp {
-    #[doc = "Calls [Fold`::fold_assign_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_assign_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AssignProp { span, key, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <Ident as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Box<Expr> as FoldWith<V>>::fold_with(value, visitor) };
-                AssignProp { span, key, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
+                        self::fields::AssignPropField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
+                        self::fields::AssignPropField::Key,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
+                        self::fields::AssignPropField::Value,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AssignTarget {
-    #[doc = "Calls [Fold`::fold_assign_target`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_assign_target(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignTarget {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_target`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_target(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AssignTarget::Simple { 0: _field_0 } => {
-                let _field_0 = <SimpleAssignTarget as FoldWith<V>>::fold_with(_field_0, visitor);
-                AssignTarget::Simple { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
+                    self::fields::AssignTargetField::Simple,
+                ));
+                <SimpleAssignTarget as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AssignTarget::Pat { 0: _field_0 } => {
-                let _field_0 = <AssignTargetPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                AssignTarget::Pat { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
+                    self::fields::AssignTargetField::Pat,
+                ));
+                <AssignTargetPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AssignTargetPat {
-    #[doc = "Calls [Fold`::fold_assign_target_pat`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_assign_target_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AssignTargetPat {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_assign_target_pat`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_assign_target_pat(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AssignTargetPat::Array { 0: _field_0 } => {
-                let _field_0 = <ArrayPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                AssignTargetPat::Array { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
+                    self::fields::AssignTargetPatField::Array,
+                ));
+                <ArrayPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AssignTargetPat::Object { 0: _field_0 } => {
-                let _field_0 = <ObjectPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                AssignTargetPat::Object { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
+                    self::fields::AssignTargetPatField::Object,
+                ));
+                <ObjectPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             AssignTargetPat::Invalid { 0: _field_0 } => {
-                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
-                AssignTargetPat::Invalid { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
+                    self::fields::AssignTargetPatField::Invalid,
+                ));
+                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AutoAccessor {
-    #[doc = "Calls [Fold`::fold_auto_accessor`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_auto_accessor(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AutoAccessor {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_auto_accessor`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_auto_accessor(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AutoAccessor {
                 span,
@@ -103582,71 +79574,154 @@ impl<V: ?Sized + Fold> FoldWith<V> for AutoAccessor {
                 is_override,
                 definite,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <Key as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let decorators =
-                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
-                let accessibility =
-                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
-                AutoAccessor {
-                    span,
-                    key,
-                    value,
-                    type_ann,
-                    is_static,
-                    decorators,
-                    accessibility,
-                    is_abstract,
-                    is_override,
-                    definite,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Key,
+                    ));
+                    <Key as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for AwaitExpr {
-    #[doc = "Calls [Fold`::fold_await_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_await_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for AwaitExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_await_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_await_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             AwaitExpr { span, arg } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
-                AwaitExpr { span, arg }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Arg));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BigInt {
-    #[doc = "Calls [Fold`::fold_big_int`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_big_int(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BigInt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_big_int`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_big_int(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             BigInt { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <Box<BigIntValue> as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                BigInt { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Value));
+                    <Box<BigIntValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BinExpr {
-    #[doc = "Calls [Fold`::fold_bin_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_bin_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_bin_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bin_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             BinExpr {
                 span,
@@ -103654,147 +79729,262 @@ impl<V: ?Sized + Fold> FoldWith<V> for BinExpr {
                 left,
                 right,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let op = { <BinaryOp as FoldWith<V>>::fold_with(op, visitor) };
-                let left = { <Box<Expr> as FoldWith<V>>::fold_with(left, visitor) };
-                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
-                BinExpr {
-                    span,
-                    op,
-                    left,
-                    right,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Op));
+                    <BinaryOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Left));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Right));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BinaryOp {
-    #[doc = "Calls [Fold`::fold_binary_op`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_binary_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BinaryOp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_binary_op`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_binary_op(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            BinaryOp::EqEq => BinaryOp::EqEq,
-            BinaryOp::NotEq => BinaryOp::NotEq,
-            BinaryOp::EqEqEq => BinaryOp::EqEqEq,
-            BinaryOp::NotEqEq => BinaryOp::NotEqEq,
-            BinaryOp::Lt => BinaryOp::Lt,
-            BinaryOp::LtEq => BinaryOp::LtEq,
-            BinaryOp::Gt => BinaryOp::Gt,
-            BinaryOp::GtEq => BinaryOp::GtEq,
-            BinaryOp::LShift => BinaryOp::LShift,
-            BinaryOp::RShift => BinaryOp::RShift,
-            BinaryOp::ZeroFillRShift => BinaryOp::ZeroFillRShift,
-            BinaryOp::Add => BinaryOp::Add,
-            BinaryOp::Sub => BinaryOp::Sub,
-            BinaryOp::Mul => BinaryOp::Mul,
-            BinaryOp::Div => BinaryOp::Div,
-            BinaryOp::Mod => BinaryOp::Mod,
-            BinaryOp::BitOr => BinaryOp::BitOr,
-            BinaryOp::BitXor => BinaryOp::BitXor,
-            BinaryOp::BitAnd => BinaryOp::BitAnd,
-            BinaryOp::LogicalOr => BinaryOp::LogicalOr,
-            BinaryOp::LogicalAnd => BinaryOp::LogicalAnd,
-            BinaryOp::In => BinaryOp::In,
-            BinaryOp::InstanceOf => BinaryOp::InstanceOf,
-            BinaryOp::Exp => BinaryOp::Exp,
-            BinaryOp::NullishCoalescing => BinaryOp::NullishCoalescing,
+            BinaryOp::EqEq => {}
+            BinaryOp::NotEq => {}
+            BinaryOp::EqEqEq => {}
+            BinaryOp::NotEqEq => {}
+            BinaryOp::Lt => {}
+            BinaryOp::LtEq => {}
+            BinaryOp::Gt => {}
+            BinaryOp::GtEq => {}
+            BinaryOp::LShift => {}
+            BinaryOp::RShift => {}
+            BinaryOp::ZeroFillRShift => {}
+            BinaryOp::Add => {}
+            BinaryOp::Sub => {}
+            BinaryOp::Mul => {}
+            BinaryOp::Div => {}
+            BinaryOp::Mod => {}
+            BinaryOp::BitOr => {}
+            BinaryOp::BitXor => {}
+            BinaryOp::BitAnd => {}
+            BinaryOp::LogicalOr => {}
+            BinaryOp::LogicalAnd => {}
+            BinaryOp::In => {}
+            BinaryOp::InstanceOf => {}
+            BinaryOp::Exp => {}
+            BinaryOp::NullishCoalescing => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BindingIdent {
-    #[doc = "Calls [Fold`::fold_binding_ident`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_binding_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BindingIdent {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_binding_ident`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_binding_ident(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             BindingIdent { id, type_ann } => {
-                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                BindingIdent { id, type_ann }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
+                        self::fields::BindingIdentField::Id,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
+                        self::fields::BindingIdentField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BlockStmt {
-    #[doc = "Calls [Fold`::fold_block_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_block_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BlockStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_block_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_block_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             BlockStmt { span, ctxt, stmts } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let stmts = { <Vec<Stmt> as FoldWith<V>>::fold_with(stmts, visitor) };
-                BlockStmt { span, ctxt, stmts }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmt(
+                        self::fields::BlockStmtField::Stmts(usize::MAX),
+                    ));
+                    <Vec<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        stmts,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BlockStmtOrExpr {
-    #[doc = "Calls [Fold`::fold_block_stmt_or_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_block_stmt_or_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BlockStmtOrExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_block_stmt_or_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_block_stmt_or_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             BlockStmtOrExpr::BlockStmt { 0: _field_0 } => {
-                let _field_0 = <BlockStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                BlockStmtOrExpr::BlockStmt { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
+                    self::fields::BlockStmtOrExprField::BlockStmt,
+                ));
+                <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             BlockStmtOrExpr::Expr { 0: _field_0 } => {
-                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
-                BlockStmtOrExpr::Expr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
+                    self::fields::BlockStmtOrExprField::Expr,
+                ));
+                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Bool {
-    #[doc = "Calls [Fold`::fold_bool`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_bool(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Bool {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_bool`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_bool(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Bool { span, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                Bool { span, value }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Bool(self::fields::BoolField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BreakStmt {
-    #[doc = "Calls [Fold`::fold_break_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_break_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BreakStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_break_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_break_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             BreakStmt { span, label } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let label = { <Option<Ident> as FoldWith<V>>::fold_with(label, visitor) };
-                BreakStmt { span, label }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BreakStmt(self::fields::BreakStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BreakStmt(
+                        self::fields::BreakStmtField::Label,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CallExpr {
-    #[doc = "Calls [Fold`::fold_call_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_call_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CallExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_call_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_call_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CallExpr {
                 span,
@@ -103803,73 +79993,147 @@ impl<V: ?Sized + Fold> FoldWith<V> for CallExpr {
                 args,
                 type_args,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let callee = { <Callee as FoldWith<V>>::fold_with(callee, visitor) };
-                let args = { <Vec<ExprOrSpread> as FoldWith<V>>::fold_with(args, visitor) };
-                let type_args = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_args, visitor,
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                CallExpr {
-                    span,
-                    ctxt,
-                    callee,
-                    args,
-                    type_args,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Callee));
+                    <Callee as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
+                        self::fields::CallExprField::Args(usize::MAX),
+                    ));
+                    <Vec<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
+                        self::fields::CallExprField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Callee {
-    #[doc = "Calls [Fold`::fold_callee`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_callee(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Callee {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_callee`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_callee(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Callee::Super { 0: _field_0 } => {
-                let _field_0 = <Super as FoldWith<V>>::fold_with(_field_0, visitor);
-                Callee::Super { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Super));
+                <Super as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Callee::Import { 0: _field_0 } => {
-                let _field_0 = <Import as FoldWith<V>>::fold_with(_field_0, visitor);
-                Callee::Import { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Import));
+                <Import as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Callee::Expr { 0: _field_0 } => {
-                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Callee::Expr { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Expr));
+                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CatchClause {
-    #[doc = "Calls [Fold`::fold_catch_clause`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_catch_clause(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CatchClause {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_catch_clause`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_catch_clause(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CatchClause { span, param, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let param = { <Option<Pat> as FoldWith<V>>::fold_with(param, visitor) };
-                let body = { <BlockStmt as FoldWith<V>>::fold_with(body, visitor) };
-                CatchClause { span, param, body }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
+                        self::fields::CatchClauseField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
+                        self::fields::CatchClauseField::Param,
+                    ));
+                    <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
+                        self::fields::CatchClauseField::Body,
+                    ));
+                    <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Class {
-    #[doc = "Calls [Fold`::fold_class`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Class {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Class {
                 span,
@@ -103882,133 +80146,264 @@ impl<V: ?Sized + Fold> FoldWith<V> for Class {
                 super_type_params,
                 implements,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let decorators =
-                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
-                let body = { <Vec<ClassMember> as FoldWith<V>>::fold_with(body, visitor) };
-                let super_class =
-                    { <Option<Box<Expr>> as FoldWith<V>>::fold_with(super_class, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let super_type_params = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        super_type_params,
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
                         visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::Body(usize::MAX),
+                    ));
+                    <Vec<ClassMember> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Class(self::fields::ClassField::SuperClass));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        super_class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Class(self::fields::ClassField::TypeParams));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::SuperTypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (super_type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::Implements(usize::MAX),
+                    ));
+                    <Vec<TsExprWithTypeArgs> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        implements,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                let implements =
-                    { <Vec<TsExprWithTypeArgs> as FoldWith<V>>::fold_with(implements, visitor) };
-                Class {
-                    span,
-                    ctxt,
-                    decorators,
-                    body,
-                    super_class,
-                    is_abstract,
-                    type_params,
-                    super_type_params,
-                    implements,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ClassDecl {
-    #[doc = "Calls [Fold`::fold_class_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ClassDecl {
                 ident,
                 declare,
                 class,
             } => {
-                let ident = { <Ident as FoldWith<V>>::fold_with(ident, visitor) };
-                let class = { <Box<Class> as FoldWith<V>>::fold_with(class, visitor) };
-                ClassDecl {
-                    ident,
-                    declare,
-                    class,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
+                        self::fields::ClassDeclField::Ident,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
+                        self::fields::ClassDeclField::Class,
+                    ));
+                    <Box<Class> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ClassExpr {
-    #[doc = "Calls [Fold`::fold_class_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ClassExpr { ident, class } => {
-                let ident = { <Option<Ident> as FoldWith<V>>::fold_with(ident, visitor) };
-                let class = { <Box<Class> as FoldWith<V>>::fold_with(class, visitor) };
-                ClassExpr { ident, class }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
+                        self::fields::ClassExprField::Ident,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
+                        self::fields::ClassExprField::Class,
+                    ));
+                    <Box<Class> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ClassMember {
-    #[doc = "Calls [Fold`::fold_class_member`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class_member(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassMember {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_member`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_member(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ClassMember::Constructor { 0: _field_0 } => {
-                let _field_0 = <Constructor as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::Constructor { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::Constructor,
+                ));
+                <Constructor as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::Method { 0: _field_0 } => {
-                let _field_0 = <ClassMethod as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::Method { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::Method,
+                ));
+                <ClassMethod as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::PrivateMethod { 0: _field_0 } => {
-                let _field_0 = <PrivateMethod as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::PrivateMethod { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::PrivateMethod,
+                ));
+                <PrivateMethod as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::ClassProp { 0: _field_0 } => {
-                let _field_0 = <ClassProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::ClassProp { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::ClassProp,
+                ));
+                <ClassProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::PrivateProp { 0: _field_0 } => {
-                let _field_0 = <PrivateProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::PrivateProp { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::PrivateProp,
+                ));
+                <PrivateProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::TsIndexSignature { 0: _field_0 } => {
-                let _field_0 = <TsIndexSignature as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::TsIndexSignature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::TsIndexSignature,
+                ));
+                <TsIndexSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::Empty { 0: _field_0 } => {
-                let _field_0 = <EmptyStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::Empty { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::Empty,
+                ));
+                <EmptyStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::StaticBlock { 0: _field_0 } => {
-                let _field_0 = <StaticBlock as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::StaticBlock { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::StaticBlock,
+                ));
+                <StaticBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ClassMember::AutoAccessor { 0: _field_0 } => {
-                let _field_0 = <AutoAccessor as FoldWith<V>>::fold_with(_field_0, visitor);
-                ClassMember::AutoAccessor { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::AutoAccessor,
+                ));
+                <AutoAccessor as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ClassMethod {
-    #[doc = "Calls [Fold`::fold_class_method`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class_method(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassMethod {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_method`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_method(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ClassMethod {
                 span,
@@ -104021,34 +80416,69 @@ impl<V: ?Sized + Fold> FoldWith<V> for ClassMethod {
                 is_optional,
                 is_override,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
-                let kind = { <MethodKind as FoldWith<V>>::fold_with(kind, visitor) };
-                let accessibility =
-                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
-                ClassMethod {
-                    span,
-                    key,
-                    function,
-                    kind,
-                    is_static,
-                    accessibility,
-                    is_abstract,
-                    is_optional,
-                    is_override,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Key,
+                    ));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Function,
+                    ));
+                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Kind,
+                    ));
+                    <MethodKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ClassProp {
-    #[doc = "Calls [Fold`::fold_class_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ClassProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ClassProp {
                 span,
@@ -104065,57 +80495,112 @@ impl<V: ?Sized + Fold> FoldWith<V> for ClassProp {
                 declare,
                 definite,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let decorators =
-                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
-                let accessibility =
-                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
-                ClassProp {
-                    span,
-                    key,
-                    value,
-                    type_ann,
-                    is_static,
-                    decorators,
-                    accessibility,
-                    is_abstract,
-                    is_optional,
-                    is_override,
-                    readonly,
-                    declare,
-                    definite,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Key));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ComputedPropName {
-    #[doc = "Calls [Fold`::fold_computed_prop_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_computed_prop_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ComputedPropName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_computed_prop_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_computed_prop_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ComputedPropName { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                ComputedPropName { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
+                        self::fields::ComputedPropNameField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
+                        self::fields::ComputedPropNameField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for CondExpr {
-    #[doc = "Calls [Fold`::fold_cond_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_cond_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for CondExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_cond_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_cond_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             CondExpr {
                 span,
@@ -104123,27 +80608,55 @@ impl<V: ?Sized + Fold> FoldWith<V> for CondExpr {
                 cons,
                 alt,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
-                let cons = { <Box<Expr> as FoldWith<V>>::fold_with(cons, visitor) };
-                let alt = { <Box<Expr> as FoldWith<V>>::fold_with(alt, visitor) };
-                CondExpr {
-                    span,
-                    test,
-                    cons,
-                    alt,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Test));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Cons));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Alt));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        alt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Constructor {
-    #[doc = "Calls [Fold`::fold_constructor`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_constructor(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Constructor {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_constructor`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_constructor(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Constructor {
                 span,
@@ -104154,201 +80667,393 @@ impl<V: ?Sized + Fold> FoldWith<V> for Constructor {
                 accessibility,
                 is_optional,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let params =
-                    { <Vec<ParamOrTsParamProp> as FoldWith<V>>::fold_with(params, visitor) };
-                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
-                let accessibility =
-                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
-                Constructor {
-                    span,
-                    ctxt,
-                    key,
-                    params,
-                    body,
-                    accessibility,
-                    is_optional,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Key,
+                    ));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Params(usize::MAX),
+                    ));
+                    <Vec<ParamOrTsParamProp> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Body,
+                    ));
+                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ContinueStmt {
-    #[doc = "Calls [Fold`::fold_continue_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_continue_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ContinueStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_continue_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_continue_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ContinueStmt { span, label } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let label = { <Option<Ident> as FoldWith<V>>::fold_with(label, visitor) };
-                ContinueStmt { span, label }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
+                        self::fields::ContinueStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
+                        self::fields::ContinueStmtField::Label,
+                    ));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DebuggerStmt {
-    #[doc = "Calls [Fold`::fold_debugger_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_debugger_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DebuggerStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_debugger_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_debugger_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DebuggerStmt { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                DebuggerStmt { span }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DebuggerStmt(
+                        self::fields::DebuggerStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Decl {
-    #[doc = "Calls [Fold`::fold_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Decl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Decl::Class { 0: _field_0 } => {
-                let _field_0 = <ClassDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::Class { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Class));
+                <ClassDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::Fn { 0: _field_0 } => {
-                let _field_0 = <FnDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::Fn { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Fn));
+                <FnDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::Var { 0: _field_0 } => {
-                let _field_0 = <Box<VarDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::Var { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Var));
+                <Box<VarDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::Using { 0: _field_0 } => {
-                let _field_0 = <Box<UsingDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::Using { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Using));
+                <Box<UsingDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsInterface { 0: _field_0 } => {
-                let _field_0 = <Box<TsInterfaceDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::TsInterface { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsInterface));
+                <Box<TsInterfaceDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsTypeAlias { 0: _field_0 } => {
-                let _field_0 = <Box<TsTypeAliasDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::TsTypeAlias { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsTypeAlias));
+                <Box<TsTypeAliasDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsEnum { 0: _field_0 } => {
-                let _field_0 = <Box<TsEnumDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::TsEnum { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsEnum));
+                <Box<TsEnumDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Decl::TsModule { 0: _field_0 } => {
-                let _field_0 = <Box<TsModuleDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Decl::TsModule { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsModule));
+                <Box<TsModuleDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Decorator {
-    #[doc = "Calls [Fold`::fold_decorator`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_decorator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Decorator {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_decorator`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decorator(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Decorator { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                Decorator { span, expr }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Expr));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DefaultDecl {
-    #[doc = "Calls [Fold`::fold_default_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_default_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DefaultDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_default_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_default_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DefaultDecl::Class { 0: _field_0 } => {
-                let _field_0 = <ClassExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                DefaultDecl::Class { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
+                    self::fields::DefaultDeclField::Class,
+                ));
+                <ClassExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DefaultDecl::Fn { 0: _field_0 } => {
-                let _field_0 = <FnExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                DefaultDecl::Fn { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
+                    self::fields::DefaultDeclField::Fn,
+                ));
+                <FnExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             DefaultDecl::TsInterfaceDecl { 0: _field_0 } => {
-                let _field_0 = <Box<TsInterfaceDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                DefaultDecl::TsInterfaceDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
+                    self::fields::DefaultDeclField::TsInterfaceDecl,
+                ));
+                <Box<TsInterfaceDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for DoWhileStmt {
-    #[doc = "Calls [Fold`::fold_do_while_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_do_while_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for DoWhileStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_do_while_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_do_while_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             DoWhileStmt { span, test, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
-                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                DoWhileStmt { span, test, body }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
+                        self::fields::DoWhileStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
+                        self::fields::DoWhileStmtField::Test,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
+                        self::fields::DoWhileStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for EmptyStmt {
-    #[doc = "Calls [Fold`::fold_empty_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_empty_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for EmptyStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_empty_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_empty_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             EmptyStmt { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                EmptyStmt { span }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::EmptyStmt(self::fields::EmptyStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for EsVersion {
-    #[doc = "Calls [Fold`::fold_es_version`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_es_version(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for EsVersion {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_es_version`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_es_version(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            EsVersion::Es3 => EsVersion::Es3,
-            EsVersion::Es5 => EsVersion::Es5,
-            EsVersion::Es2015 => EsVersion::Es2015,
-            EsVersion::Es2016 => EsVersion::Es2016,
-            EsVersion::Es2017 => EsVersion::Es2017,
-            EsVersion::Es2018 => EsVersion::Es2018,
-            EsVersion::Es2019 => EsVersion::Es2019,
-            EsVersion::Es2020 => EsVersion::Es2020,
-            EsVersion::Es2021 => EsVersion::Es2021,
-            EsVersion::Es2022 => EsVersion::Es2022,
-            EsVersion::EsNext => EsVersion::EsNext,
+            EsVersion::Es3 => {}
+            EsVersion::Es5 => {}
+            EsVersion::Es2015 => {}
+            EsVersion::Es2016 => {}
+            EsVersion::Es2017 => {}
+            EsVersion::Es2018 => {}
+            EsVersion::Es2019 => {}
+            EsVersion::Es2020 => {}
+            EsVersion::Es2021 => {}
+            EsVersion::Es2022 => {}
+            EsVersion::EsNext => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportAll {
-    #[doc = "Calls [Fold`::fold_export_all`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_all(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportAll {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_all`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_all(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportAll {
                 span,
@@ -104356,89 +81061,177 @@ impl<V: ?Sized + Fold> FoldWith<V> for ExportAll {
                 type_only,
                 with,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let src = { <Box<Str> as FoldWith<V>>::fold_with(src, visitor) };
-                let with = { <Option<Box<ObjectLit>> as FoldWith<V>>::fold_with(with, visitor) };
-                ExportAll {
-                    span,
-                    src,
-                    type_only,
-                    with,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Src));
+                    <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::With));
+                    <Option<Box<ObjectLit>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportDecl {
-    #[doc = "Calls [Fold`::fold_export_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportDecl { span, decl } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let decl = { <Decl as FoldWith<V>>::fold_with(decl, visitor) };
-                ExportDecl { span, decl }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
+                        self::fields::ExportDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
+                        self::fields::ExportDeclField::Decl,
+                    ));
+                    <Decl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportDefaultDecl {
-    #[doc = "Calls [Fold`::fold_export_default_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_default_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDefaultDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_default_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_default_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportDefaultDecl { span, decl } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let decl = { <DefaultDecl as FoldWith<V>>::fold_with(decl, visitor) };
-                ExportDefaultDecl { span, decl }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
+                        self::fields::ExportDefaultDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
+                        self::fields::ExportDefaultDeclField::Decl,
+                    ));
+                    <DefaultDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportDefaultExpr {
-    #[doc = "Calls [Fold`::fold_export_default_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_default_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDefaultExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_default_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_default_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportDefaultExpr { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                ExportDefaultExpr { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
+                        self::fields::ExportDefaultExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
+                        self::fields::ExportDefaultExprField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportDefaultSpecifier {
-    #[doc = "Calls [Fold`::fold_export_default_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_default_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportDefaultSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_default_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_default_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportDefaultSpecifier { exported } => {
-                let exported = { <Ident as FoldWith<V>>::fold_with(exported, visitor) };
-                ExportDefaultSpecifier { exported }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportDefaultSpecifier(
+                            self::fields::ExportDefaultSpecifierField::Exported,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        exported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportNamedSpecifier {
-    #[doc = "Calls [Fold`::fold_export_named_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_named_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportNamedSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_named_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_named_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportNamedSpecifier {
                 span,
@@ -104446,327 +81239,670 @@ impl<V: ?Sized + Fold> FoldWith<V> for ExportNamedSpecifier {
                 exported,
                 is_type_only,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let orig = { <ModuleExportName as FoldWith<V>>::fold_with(orig, visitor) };
-                let exported =
-                    { <Option<ModuleExportName> as FoldWith<V>>::fold_with(exported, visitor) };
-                ExportNamedSpecifier {
-                    span,
-                    orig,
-                    exported,
-                    is_type_only,
-                }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
+                            self::fields::ExportNamedSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
+                            self::fields::ExportNamedSpecifierField::Orig,
+                        ));
+                    <ModuleExportName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        orig,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
+                            self::fields::ExportNamedSpecifierField::Exported,
+                        ));
+                    <Option<ModuleExportName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        exported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportNamespaceSpecifier {
-    #[doc = "Calls [Fold`::fold_export_namespace_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_namespace_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportNamespaceSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_namespace_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_namespace_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportNamespaceSpecifier { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <ModuleExportName as FoldWith<V>>::fold_with(name, visitor) };
-                ExportNamespaceSpecifier { span, name }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
+                            self::fields::ExportNamespaceSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
+                            self::fields::ExportNamespaceSpecifierField::Name,
+                        ));
+                    <ModuleExportName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExportSpecifier {
-    #[doc = "Calls [Fold`::fold_export_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExportSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExportSpecifier::Namespace { 0: _field_0 } => {
-                let _field_0 =
-                    <ExportNamespaceSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
-                ExportSpecifier::Namespace { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
+                    self::fields::ExportSpecifierField::Namespace,
+                ));
+                <ExportNamespaceSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ExportSpecifier::Default { 0: _field_0 } => {
-                let _field_0 =
-                    <ExportDefaultSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
-                ExportSpecifier::Default { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
+                    self::fields::ExportSpecifierField::Default,
+                ));
+                <ExportDefaultSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ExportSpecifier::Named { 0: _field_0 } => {
-                let _field_0 = <ExportNamedSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
-                ExportSpecifier::Named { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
+                    self::fields::ExportSpecifierField::Named,
+                ));
+                <ExportNamedSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Expr {
-    #[doc = "Calls [Fold`::fold_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Expr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Expr::This { 0: _field_0 } => {
-                let _field_0 = <ThisExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::This { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::This));
+                <ThisExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Array { 0: _field_0 } => {
-                let _field_0 = <ArrayLit as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Array { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Array));
+                <ArrayLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Object { 0: _field_0 } => {
-                let _field_0 = <ObjectLit as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Object { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Object));
+                <ObjectLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Fn { 0: _field_0 } => {
-                let _field_0 = <FnExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Fn { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Fn));
+                <FnExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Unary { 0: _field_0 } => {
-                let _field_0 = <UnaryExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Unary { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Unary));
+                <UnaryExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Update { 0: _field_0 } => {
-                let _field_0 = <UpdateExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Update { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Update));
+                <UpdateExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Bin { 0: _field_0 } => {
-                let _field_0 = <BinExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Bin { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Bin));
+                <BinExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Assign { 0: _field_0 } => {
-                let _field_0 = <AssignExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Assign { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Assign));
+                <AssignExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Member { 0: _field_0 } => {
-                let _field_0 = <MemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Member { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Member));
+                <MemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::SuperProp { 0: _field_0 } => {
-                let _field_0 = <SuperPropExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::SuperProp { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::SuperProp));
+                <SuperPropExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Cond { 0: _field_0 } => {
-                let _field_0 = <CondExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Cond { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Cond));
+                <CondExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Call { 0: _field_0 } => {
-                let _field_0 = <CallExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Call { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Call));
+                <CallExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::New { 0: _field_0 } => {
-                let _field_0 = <NewExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::New { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::New));
+                <NewExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Seq { 0: _field_0 } => {
-                let _field_0 = <SeqExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Seq { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Seq));
+                <SeqExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Ident { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Ident));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Lit { 0: _field_0 } => {
-                let _field_0 = <Lit as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Lit { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Lit));
+                <Lit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Tpl { 0: _field_0 } => {
-                let _field_0 = <Tpl as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Tpl { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Tpl));
+                <Tpl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TaggedTpl { 0: _field_0 } => {
-                let _field_0 = <TaggedTpl as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::TaggedTpl { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TaggedTpl));
+                <TaggedTpl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Arrow { 0: _field_0 } => {
-                let _field_0 = <ArrowExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Arrow { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Arrow));
+                <ArrowExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Class { 0: _field_0 } => {
-                let _field_0 = <ClassExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Class { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Class));
+                <ClassExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Yield { 0: _field_0 } => {
-                let _field_0 = <YieldExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Yield { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Yield));
+                <YieldExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::MetaProp { 0: _field_0 } => {
-                let _field_0 = <MetaPropExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::MetaProp { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::MetaProp));
+                <MetaPropExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Await { 0: _field_0 } => {
-                let _field_0 = <AwaitExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Await { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Await));
+                <AwaitExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Paren { 0: _field_0 } => {
-                let _field_0 = <ParenExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Paren { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Paren));
+                <ParenExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXMember { 0: _field_0 } => {
-                let _field_0 = <JSXMemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::JSXMember { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxmember));
+                <JSXMemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXNamespacedName { 0: _field_0 } => {
-                let _field_0 = <JSXNamespacedName as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::JSXNamespacedName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::JsxnamespacedName,
+                ));
+                <JSXNamespacedName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXEmpty { 0: _field_0 } => {
-                let _field_0 = <JSXEmptyExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::JSXEmpty { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxempty));
+                <JSXEmptyExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXElement { 0: _field_0 } => {
-                let _field_0 = <Box<JSXElement> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::JSXElement { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxelement));
+                <Box<JSXElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::JSXFragment { 0: _field_0 } => {
-                let _field_0 = <JSXFragment as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::JSXFragment { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxfragment));
+                <JSXFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsTypeAssertion { 0: _field_0 } => {
-                let _field_0 = <TsTypeAssertion as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::TsTypeAssertion { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::TsTypeAssertion,
+                ));
+                <TsTypeAssertion as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsConstAssertion { 0: _field_0 } => {
-                let _field_0 = <TsConstAssertion as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::TsConstAssertion { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::TsConstAssertion,
+                ));
+                <TsConstAssertion as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsNonNull { 0: _field_0 } => {
-                let _field_0 = <TsNonNullExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::TsNonNull { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsNonNull));
+                <TsNonNullExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsAs { 0: _field_0 } => {
-                let _field_0 = <TsAsExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::TsAs { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsAs));
+                <TsAsExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsInstantiation { 0: _field_0 } => {
-                let _field_0 = <TsInstantiation as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::TsInstantiation { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::TsInstantiation,
+                ));
+                <TsInstantiation as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::TsSatisfies { 0: _field_0 } => {
-                let _field_0 = <TsSatisfiesExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::TsSatisfies { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Expr(self::fields::ExprField::TsSatisfies));
+                <TsSatisfiesExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::PrivateName { 0: _field_0 } => {
-                let _field_0 = <PrivateName as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::PrivateName { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Expr(self::fields::ExprField::PrivateName));
+                <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::OptChain { 0: _field_0 } => {
-                let _field_0 = <OptChainExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::OptChain { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::OptChain));
+                <OptChainExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Expr::Invalid { 0: _field_0 } => {
-                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
-                Expr::Invalid { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Invalid));
+                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExprOrSpread {
-    #[doc = "Calls [Fold`::fold_expr_or_spread`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_expr_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExprOrSpread {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr_or_spread`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr_or_spread(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExprOrSpread { spread, expr } => {
-                let spread =
-                    { <Option<swc_common::Span> as FoldWith<V>>::fold_with(spread, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                ExprOrSpread { spread, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
+                        self::fields::ExprOrSpreadField::Spread,
+                    ));
+                    <Option<swc_common::Span> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        spread,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
+                        self::fields::ExprOrSpreadField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ExprStmt {
-    #[doc = "Calls [Fold`::fold_expr_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_expr_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ExprStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ExprStmt { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                ExprStmt { span, expr }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Expr));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for FnDecl {
-    #[doc = "Calls [Fold`::fold_fn_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_fn_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FnDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_fn_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_fn_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             FnDecl {
                 ident,
                 declare,
                 function,
             } => {
-                let ident = { <Ident as FoldWith<V>>::fold_with(ident, visitor) };
-                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
-                FnDecl {
-                    ident,
-                    declare,
-                    function,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Ident));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Function));
+                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for FnExpr {
-    #[doc = "Calls [Fold`::fold_fn_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_fn_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for FnExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_fn_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_fn_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             FnExpr { ident, function } => {
-                let ident = { <Option<Ident> as FoldWith<V>>::fold_with(ident, visitor) };
-                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
-                FnExpr { ident, function }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Ident));
+                    <Option<Ident> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Function));
+                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForHead {
-    #[doc = "Calls [Fold`::fold_for_head`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_for_head(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForHead {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_head`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_head(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForHead::VarDecl { 0: _field_0 } => {
-                let _field_0 = <Box<VarDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ForHead::VarDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::ForHead(self::fields::ForHeadField::VarDecl));
+                <Box<VarDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForHead::UsingDecl { 0: _field_0 } => {
-                let _field_0 = <Box<UsingDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ForHead::UsingDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ForHead(
+                    self::fields::ForHeadField::UsingDecl,
+                ));
+                <Box<UsingDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ForHead::Pat { 0: _field_0 } => {
-                let _field_0 = <Box<Pat> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ForHead::Pat { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForHead(self::fields::ForHeadField::Pat));
+                <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForInStmt {
-    #[doc = "Calls [Fold`::fold_for_in_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_for_in_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForInStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_in_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_in_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForInStmt {
                 span,
@@ -104774,27 +81910,56 @@ impl<V: ?Sized + Fold> FoldWith<V> for ForInStmt {
                 right,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <ForHead as FoldWith<V>>::fold_with(left, visitor) };
-                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
-                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                ForInStmt {
-                    span,
-                    left,
-                    right,
-                    body,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Left));
+                    <ForHead as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForInStmt(
+                        self::fields::ForInStmtField::Right,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Body));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForOfStmt {
-    #[doc = "Calls [Fold`::fold_for_of_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_for_of_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForOfStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_of_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_of_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForOfStmt {
                 span,
@@ -104803,28 +81968,56 @@ impl<V: ?Sized + Fold> FoldWith<V> for ForOfStmt {
                 right,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <ForHead as FoldWith<V>>::fold_with(left, visitor) };
-                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
-                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                ForOfStmt {
-                    span,
-                    is_await,
-                    left,
-                    right,
-                    body,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Left));
+                    <ForHead as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForOfStmt(
+                        self::fields::ForOfStmtField::Right,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Body));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ForStmt {
-    #[doc = "Calls [Fold`::fold_for_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_for_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ForStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_for_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_for_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ForStmt {
                 span,
@@ -104833,29 +82026,64 @@ impl<V: ?Sized + Fold> FoldWith<V> for ForStmt {
                 update,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let init = { <Option<VarDeclOrExpr> as FoldWith<V>>::fold_with(init, visitor) };
-                let test = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(test, visitor) };
-                let update = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(update, visitor) };
-                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                ForStmt {
-                    span,
-                    init,
-                    test,
-                    update,
-                    body,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Init));
+                    <Option<VarDeclOrExpr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Test));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Update));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        update,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Body));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Function {
-    #[doc = "Calls [Fold`::fold_function`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Function {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_function`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_function(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Function {
                 params,
@@ -104868,39 +82096,82 @@ impl<V: ?Sized + Fold> FoldWith<V> for Function {
                 type_params,
                 return_type,
             } => {
-                let params = { <Vec<Param> as FoldWith<V>>::fold_with(params, visitor) };
-                let decorators =
-                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::Params(usize::MAX),
+                    ));
+                    <Vec<Param> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Body));
+                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::ReturnType,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        return_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let return_type =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(return_type, visitor) };
-                Function {
-                    params,
-                    decorators,
-                    span,
-                    ctxt,
-                    body,
-                    is_generator,
-                    is_async,
-                    type_params,
-                    return_type,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for GetterProp {
-    #[doc = "Calls [Fold`::fold_getter_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_getter_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for GetterProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_getter_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_getter_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             GetterProp {
                 span,
@@ -104908,28 +82179,59 @@ impl<V: ?Sized + Fold> FoldWith<V> for GetterProp {
                 type_ann,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
-                GetterProp {
-                    span,
-                    key,
-                    type_ann,
-                    body,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::Key,
+                    ));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::Body,
+                    ));
+                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Ident {
-    #[doc = "Calls [Fold`::fold_ident`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Ident {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ident`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Ident {
                 span,
@@ -104937,42 +82239,79 @@ impl<V: ?Sized + Fold> FoldWith<V> for Ident {
                 sym,
                 optional,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let sym = { <swc_atoms::Atom as FoldWith<V>>::fold_with(sym, visitor) };
-                Ident {
-                    span,
-                    ctxt,
-                    sym,
-                    optional,
-                }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Sym));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        sym,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for IdentName {
-    #[doc = "Calls [Fold`::fold_ident_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ident_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for IdentName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ident_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ident_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             IdentName { span, sym } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let sym = { <swc_atoms::Atom as FoldWith<V>>::fold_with(sym, visitor) };
-                IdentName { span, sym }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Sym));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        sym,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for IfStmt {
-    #[doc = "Calls [Fold`::fold_if_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_if_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for IfStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_if_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_if_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             IfStmt {
                 span,
@@ -104980,43 +82319,88 @@ impl<V: ?Sized + Fold> FoldWith<V> for IfStmt {
                 cons,
                 alt,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
-                let cons = { <Box<Stmt> as FoldWith<V>>::fold_with(cons, visitor) };
-                let alt = { <Option<Box<Stmt>> as FoldWith<V>>::fold_with(alt, visitor) };
-                IfStmt {
-                    span,
-                    test,
-                    cons,
-                    alt,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Test));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Cons));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Alt));
+                    <Option<Box<Stmt>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        alt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Import {
-    #[doc = "Calls [Fold`::fold_import`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Import {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Import { span, phase } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let phase = { <ImportPhase as FoldWith<V>>::fold_with(phase, visitor) };
-                Import { span, phase }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Import(self::fields::ImportField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Import(self::fields::ImportField::Phase));
+                    <ImportPhase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        phase,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportDecl {
-    #[doc = "Calls [Fold`::fold_import_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportDecl {
                 span,
@@ -105026,47 +82410,106 @@ impl<V: ?Sized + Fold> FoldWith<V> for ImportDecl {
                 with,
                 phase,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let specifiers =
-                    { <Vec<ImportSpecifier> as FoldWith<V>>::fold_with(specifiers, visitor) };
-                let src = { <Box<Str> as FoldWith<V>>::fold_with(src, visitor) };
-                let with = { <Option<Box<ObjectLit>> as FoldWith<V>>::fold_with(with, visitor) };
-                let phase = { <ImportPhase as FoldWith<V>>::fold_with(phase, visitor) };
-                ImportDecl {
-                    span,
-                    specifiers,
-                    src,
-                    type_only,
-                    with,
-                    phase,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Specifiers(usize::MAX),
+                    ));
+                    <Vec<ImportSpecifier> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        specifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Src,
+                    ));
+                    <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::With,
+                    ));
+                    <Option<Box<ObjectLit>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Phase,
+                    ));
+                    <ImportPhase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        phase,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportDefaultSpecifier {
-    #[doc = "Calls [Fold`::fold_import_default_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_default_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportDefaultSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_default_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_default_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportDefaultSpecifier { span, local } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let local = { <Ident as FoldWith<V>>::fold_with(local, visitor) };
-                ImportDefaultSpecifier { span, local }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
+                            self::fields::ImportDefaultSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
+                            self::fields::ImportDefaultSpecifierField::Local,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportNamedSpecifier {
-    #[doc = "Calls [Fold`::fold_import_named_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_named_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportNamedSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_named_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_named_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportNamedSpecifier {
                 span,
@@ -105074,241 +82517,463 @@ impl<V: ?Sized + Fold> FoldWith<V> for ImportNamedSpecifier {
                 imported,
                 is_type_only,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let local = { <Ident as FoldWith<V>>::fold_with(local, visitor) };
-                let imported =
-                    { <Option<ModuleExportName> as FoldWith<V>>::fold_with(imported, visitor) };
-                ImportNamedSpecifier {
-                    span,
-                    local,
-                    imported,
-                    is_type_only,
-                }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
+                            self::fields::ImportNamedSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
+                            self::fields::ImportNamedSpecifierField::Local,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
+                            self::fields::ImportNamedSpecifierField::Imported,
+                        ));
+                    <Option<ModuleExportName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        imported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportPhase {
-    #[doc = "Calls [Fold`::fold_import_phase`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_phase(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportPhase {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_phase`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_phase(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            ImportPhase::Evaluation => ImportPhase::Evaluation,
-            ImportPhase::Source => ImportPhase::Source,
-            ImportPhase::Defer => ImportPhase::Defer,
+            ImportPhase::Evaluation => {}
+            ImportPhase::Source => {}
+            ImportPhase::Defer => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportSpecifier {
-    #[doc = "Calls [Fold`::fold_import_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportSpecifier::Named { 0: _field_0 } => {
-                let _field_0 = <ImportNamedSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
-                ImportSpecifier::Named { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
+                    self::fields::ImportSpecifierField::Named,
+                ));
+                <ImportNamedSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportSpecifier::Default { 0: _field_0 } => {
-                let _field_0 =
-                    <ImportDefaultSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
-                ImportSpecifier::Default { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
+                    self::fields::ImportSpecifierField::Default,
+                ));
+                <ImportDefaultSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ImportSpecifier::Namespace { 0: _field_0 } => {
-                let _field_0 = <ImportStarAsSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
-                ImportSpecifier::Namespace { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
+                    self::fields::ImportSpecifierField::Namespace,
+                ));
+                <ImportStarAsSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportStarAsSpecifier {
-    #[doc = "Calls [Fold`::fold_import_star_as_specifier`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_star_as_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportStarAsSpecifier {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_star_as_specifier`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_star_as_specifier(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportStarAsSpecifier { span, local } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let local = { <Ident as FoldWith<V>>::fold_with(local, visitor) };
-                ImportStarAsSpecifier { span, local }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
+                            self::fields::ImportStarAsSpecifierField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
+                            self::fields::ImportStarAsSpecifierField::Local,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportWith {
-    #[doc = "Calls [Fold`::fold_import_with`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_with(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportWith {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_with`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_with(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportWith { span, values } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let values = { <Vec<ImportWithItem> as FoldWith<V>>::fold_with(values, visitor) };
-                ImportWith { span, values }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
+                        self::fields::ImportWithField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
+                        self::fields::ImportWithField::Values(usize::MAX),
+                    ));
+                    <Vec<ImportWithItem> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        values,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ImportWithItem {
-    #[doc = "Calls [Fold`::fold_import_with_item`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_with_item(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ImportWithItem {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_with_item`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_with_item(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ImportWithItem { key, value } => {
-                let key = { <IdentName as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Str as FoldWith<V>>::fold_with(value, visitor) };
-                ImportWithItem { key, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
+                        self::fields::ImportWithItemField::Key,
+                    ));
+                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
+                        self::fields::ImportWithItemField::Value,
+                    ));
+                    <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Invalid {
-    #[doc = "Calls [Fold`::fold_invalid`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_invalid(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Invalid {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_invalid`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_invalid(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Invalid { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                Invalid { span }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Invalid(self::fields::InvalidField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXAttr {
-    #[doc = "Calls [Fold`::fold_jsx_attr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_attr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXAttr { span, name, value } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <JSXAttrName as FoldWith<V>>::fold_with(name, visitor) };
-                let value = { <Option<JSXAttrValue> as FoldWith<V>>::fold_with(value, visitor) };
-                JSXAttr { span, name, value }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Name));
+                    <JSXAttrName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Value));
+                    <Option<JSXAttrValue> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXAttrName {
-    #[doc = "Calls [Fold`::fold_jsx_attr_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_attr_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttrName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXAttrName::Ident { 0: _field_0 } => {
-                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
+                    self::fields::JSXAttrNameField::Ident,
+                ));
+                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrName::JSXNamespacedName { 0: _field_0 } => {
-                let _field_0 = <JSXNamespacedName as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrName::JSXNamespacedName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
+                    self::fields::JSXAttrNameField::JsxnamespacedName,
+                ));
+                <JSXNamespacedName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXAttrOrSpread {
-    #[doc = "Calls [Fold`::fold_jsx_attr_or_spread`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_attr_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttrOrSpread {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_or_spread`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spread(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
-                let _field_0 = <JSXAttr as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrOrSpread::JSXAttr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
+                    self::fields::JSXAttrOrSpreadField::Jsxattr,
+                ));
+                <JSXAttr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
-                let _field_0 = <SpreadElement as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrOrSpread::SpreadElement { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
+                    self::fields::JSXAttrOrSpreadField::SpreadElement,
+                ));
+                <SpreadElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXAttrValue {
-    #[doc = "Calls [Fold`::fold_jsx_attr_value`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_attr_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXAttrValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_value`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_value(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXAttrValue::Lit { 0: _field_0 } => {
-                let _field_0 = <Lit as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrValue::Lit { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::Lit,
+                ));
+                <Lit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrValue::JSXExprContainer { 0: _field_0 } => {
-                let _field_0 = <JSXExprContainer as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrValue::JSXExprContainer { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::JsxexprContainer,
+                ));
+                <JSXExprContainer as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrValue::JSXElement { 0: _field_0 } => {
-                let _field_0 = <Box<JSXElement> as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrValue::JSXElement { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::Jsxelement,
+                ));
+                <Box<JSXElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXAttrValue::JSXFragment { 0: _field_0 } => {
-                let _field_0 = <JSXFragment as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXAttrValue::JSXFragment { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::Jsxfragment,
+                ));
+                <JSXFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXClosingElement {
-    #[doc = "Calls [Fold`::fold_jsx_closing_element`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_closing_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXClosingElement {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_closing_element`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_closing_element(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXClosingElement { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <JSXElementName as FoldWith<V>>::fold_with(name, visitor) };
-                JSXClosingElement { span, name }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
+                        self::fields::JSXClosingElementField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
+                        self::fields::JSXClosingElementField::Name,
+                    ));
+                    <JSXElementName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXClosingFragment {
-    #[doc = "Calls [Fold`::fold_jsx_closing_fragment`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_closing_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXClosingFragment {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_closing_fragment`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_closing_fragment(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXClosingFragment { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                JSXClosingFragment { span }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingFragment(
+                        self::fields::JSXClosingFragmentField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXElement {
-    #[doc = "Calls [Fold`::fold_jsx_element`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXElement {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXElement {
                 span,
@@ -105316,133 +82981,257 @@ impl<V: ?Sized + Fold> FoldWith<V> for JSXElement {
                 children,
                 closing,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let opening = { <JSXOpeningElement as FoldWith<V>>::fold_with(opening, visitor) };
-                let children =
-                    { <Vec<JSXElementChild> as FoldWith<V>>::fold_with(children, visitor) };
-                let closing =
-                    { <Option<JSXClosingElement> as FoldWith<V>>::fold_with(closing, visitor) };
-                JSXElement {
-                    span,
-                    opening,
-                    children,
-                    closing,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Opening,
+                    ));
+                    <JSXOpeningElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        opening,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Children(usize::MAX),
+                    ));
+                    <Vec<JSXElementChild> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Closing,
+                    ));
+                    <Option<JSXClosingElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        closing,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXElementChild {
-    #[doc = "Calls [Fold`::fold_jsx_element_child`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_element_child(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXElementChild {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element_child`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_child(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXElementChild::JSXText { 0: _field_0 } => {
-                let _field_0 = <JSXText as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementChild::JSXText { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::Jsxtext,
+                ));
+                <JSXText as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXExprContainer { 0: _field_0 } => {
-                let _field_0 = <JSXExprContainer as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementChild::JSXExprContainer { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::JsxexprContainer,
+                ));
+                <JSXExprContainer as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXSpreadChild { 0: _field_0 } => {
-                let _field_0 = <JSXSpreadChild as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementChild::JSXSpreadChild { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::JsxspreadChild,
+                ));
+                <JSXSpreadChild as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXElement { 0: _field_0 } => {
-                let _field_0 = <Box<JSXElement> as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementChild::JSXElement { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::Jsxelement,
+                ));
+                <Box<JSXElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementChild::JSXFragment { 0: _field_0 } => {
-                let _field_0 = <JSXFragment as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementChild::JSXFragment { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::Jsxfragment,
+                ));
+                <JSXFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXElementName {
-    #[doc = "Calls [Fold`::fold_jsx_element_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_element_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXElementName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXElementName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
+                    self::fields::JSXElementNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementName::JSXMemberExpr { 0: _field_0 } => {
-                let _field_0 = <JSXMemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementName::JSXMemberExpr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
+                    self::fields::JSXElementNameField::JsxmemberExpr,
+                ));
+                <JSXMemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXElementName::JSXNamespacedName { 0: _field_0 } => {
-                let _field_0 = <JSXNamespacedName as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXElementName::JSXNamespacedName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
+                    self::fields::JSXElementNameField::JsxnamespacedName,
+                ));
+                <JSXNamespacedName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXEmptyExpr {
-    #[doc = "Calls [Fold`::fold_jsx_empty_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_empty_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXEmptyExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_empty_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_empty_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXEmptyExpr { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                JSXEmptyExpr { span }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXEmptyExpr(
+                        self::fields::JSXEmptyExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXExpr {
-    #[doc = "Calls [Fold`::fold_jsx_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXExpr::JSXEmptyExpr { 0: _field_0 } => {
-                let _field_0 = <JSXEmptyExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXExpr::JSXEmptyExpr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExpr(
+                    self::fields::JSXExprField::JsxemptyExpr,
+                ));
+                <JSXEmptyExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXExpr::Expr { 0: _field_0 } => {
-                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXExpr::Expr { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::JSXExpr(self::fields::JSXExprField::Expr));
+                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXExprContainer {
-    #[doc = "Calls [Fold`::fold_jsx_expr_container`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_expr_container(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXExprContainer {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_expr_container`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_expr_container(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXExprContainer { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <JSXExpr as FoldWith<V>>::fold_with(expr, visitor) };
-                JSXExprContainer { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
+                        self::fields::JSXExprContainerField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
+                        self::fields::JSXExprContainerField::Expr,
+                    ));
+                    <JSXExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXFragment {
-    #[doc = "Calls [Fold`::fold_jsx_fragment`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXFragment {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_fragment`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_fragment(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXFragment {
                 span,
@@ -105450,81 +83239,182 @@ impl<V: ?Sized + Fold> FoldWith<V> for JSXFragment {
                 children,
                 closing,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let opening = { <JSXOpeningFragment as FoldWith<V>>::fold_with(opening, visitor) };
-                let children =
-                    { <Vec<JSXElementChild> as FoldWith<V>>::fold_with(children, visitor) };
-                let closing = { <JSXClosingFragment as FoldWith<V>>::fold_with(closing, visitor) };
-                JSXFragment {
-                    span,
-                    opening,
-                    children,
-                    closing,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Opening,
+                    ));
+                    <JSXOpeningFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        opening,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Children(usize::MAX),
+                    ));
+                    <Vec<JSXElementChild> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Closing,
+                    ));
+                    <JSXClosingFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        closing,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXMemberExpr {
-    #[doc = "Calls [Fold`::fold_jsx_member_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_member_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXMemberExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_member_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_member_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXMemberExpr { span, obj, prop } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let obj = { <JSXObject as FoldWith<V>>::fold_with(obj, visitor) };
-                let prop = { <IdentName as FoldWith<V>>::fold_with(prop, visitor) };
-                JSXMemberExpr { span, obj, prop }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
+                        self::fields::JSXMemberExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
+                        self::fields::JSXMemberExprField::Obj,
+                    ));
+                    <JSXObject as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
+                        self::fields::JSXMemberExprField::Prop,
+                    ));
+                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXNamespacedName {
-    #[doc = "Calls [Fold`::fold_jsx_namespaced_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_namespaced_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXNamespacedName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_namespaced_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_namespaced_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXNamespacedName { span, ns, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ns = { <IdentName as FoldWith<V>>::fold_with(ns, visitor) };
-                let name = { <IdentName as FoldWith<V>>::fold_with(name, visitor) };
-                JSXNamespacedName { span, ns, name }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
+                        self::fields::JSXNamespacedNameField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
+                        self::fields::JSXNamespacedNameField::Ns,
+                    ));
+                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ns,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
+                        self::fields::JSXNamespacedNameField::Name,
+                    ));
+                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXObject {
-    #[doc = "Calls [Fold`::fold_jsx_object`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_object(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXObject {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_object`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_object(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXObject::JSXMemberExpr { 0: _field_0 } => {
-                let _field_0 = <Box<JSXMemberExpr> as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXObject::JSXMemberExpr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
+                    self::fields::JSXObjectField::JsxmemberExpr,
+                ));
+                <Box<JSXMemberExpr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             JSXObject::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                JSXObject::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
+                    self::fields::JSXObjectField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXOpeningElement {
-    #[doc = "Calls [Fold`::fold_jsx_opening_element`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_opening_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXOpeningElement {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_opening_element`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_opening_element(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXOpeningElement {
                 name,
@@ -105533,398 +83423,784 @@ impl<V: ?Sized + Fold> FoldWith<V> for JSXOpeningElement {
                 self_closing,
                 type_args,
             } => {
-                let name = { <JSXElementName as FoldWith<V>>::fold_with(name, visitor) };
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let attrs = { <Vec<JSXAttrOrSpread> as FoldWith<V>>::fold_with(attrs, visitor) };
-                let type_args = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_args, visitor,
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::Name,
+                    ));
+                    <JSXElementName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                JSXOpeningElement {
-                    name,
-                    span,
-                    attrs,
-                    self_closing,
-                    type_args,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::Attrs(usize::MAX),
+                    ));
+                    <Vec<JSXAttrOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        attrs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXOpeningFragment {
-    #[doc = "Calls [Fold`::fold_jsx_opening_fragment`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_opening_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXOpeningFragment {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_opening_fragment`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_opening_fragment(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXOpeningFragment { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                JSXOpeningFragment { span }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningFragment(
+                        self::fields::JSXOpeningFragmentField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXSpreadChild {
-    #[doc = "Calls [Fold`::fold_jsx_spread_child`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_spread_child(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXSpreadChild {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_spread_child`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_spread_child(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXSpreadChild { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                JSXSpreadChild { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
+                        self::fields::JSXSpreadChildField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
+                        self::fields::JSXSpreadChildField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for JSXText {
-    #[doc = "Calls [Fold`::fold_jsx_text`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_text(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for JSXText {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_text`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_text(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             JSXText { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                JSXText { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Raw));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Key {
-    #[doc = "Calls [Fold`::fold_key`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_key(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Key {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_key`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_key(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Key::Private { 0: _field_0 } => {
-                let _field_0 = <PrivateName as FoldWith<V>>::fold_with(_field_0, visitor);
-                Key::Private { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Private));
+                <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Key::Public { 0: _field_0 } => {
-                let _field_0 = <PropName as FoldWith<V>>::fold_with(_field_0, visitor);
-                Key::Public { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Public));
+                <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for KeyValuePatProp {
-    #[doc = "Calls [Fold`::fold_key_value_pat_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_key_value_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyValuePatProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_key_value_pat_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_key_value_pat_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             KeyValuePatProp { key, value } => {
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Box<Pat> as FoldWith<V>>::fold_with(value, visitor) };
-                KeyValuePatProp { key, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
+                        self::fields::KeyValuePatPropField::Key,
+                    ));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
+                        self::fields::KeyValuePatPropField::Value,
+                    ));
+                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for KeyValueProp {
-    #[doc = "Calls [Fold`::fold_key_value_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_key_value_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for KeyValueProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_key_value_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_key_value_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             KeyValueProp { key, value } => {
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Box<Expr> as FoldWith<V>>::fold_with(value, visitor) };
-                KeyValueProp { key, value }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
+                        self::fields::KeyValuePropField::Key,
+                    ));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
+                        self::fields::KeyValuePropField::Value,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for LabeledStmt {
-    #[doc = "Calls [Fold`::fold_labeled_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_labeled_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for LabeledStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_labeled_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_labeled_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             LabeledStmt { span, label, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let label = { <Ident as FoldWith<V>>::fold_with(label, visitor) };
-                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                LabeledStmt { span, label, body }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
+                        self::fields::LabeledStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
+                        self::fields::LabeledStmtField::Label,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
+                        self::fields::LabeledStmtField::Body,
+                    ));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Lit {
-    #[doc = "Calls [Fold`::fold_lit`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Lit {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_lit`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_lit(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Lit::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                Lit::Str { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Str));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Bool { 0: _field_0 } => {
-                let _field_0 = <Bool as FoldWith<V>>::fold_with(_field_0, visitor);
-                Lit::Bool { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Bool));
+                <Bool as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Null { 0: _field_0 } => {
-                let _field_0 = <Null as FoldWith<V>>::fold_with(_field_0, visitor);
-                Lit::Null { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Null));
+                <Null as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Num { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                Lit::Num { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Num));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::BigInt { 0: _field_0 } => {
-                let _field_0 = <BigInt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Lit::BigInt { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::BigInt));
+                <BigInt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::Regex { 0: _field_0 } => {
-                let _field_0 = <Regex as FoldWith<V>>::fold_with(_field_0, visitor);
-                Lit::Regex { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Regex));
+                <Regex as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Lit::JSXText { 0: _field_0 } => {
-                let _field_0 = <JSXText as FoldWith<V>>::fold_with(_field_0, visitor);
-                Lit::JSXText { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Jsxtext));
+                <JSXText as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MemberExpr {
-    #[doc = "Calls [Fold`::fold_member_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_member_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MemberExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_member_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_member_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MemberExpr { span, obj, prop } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let obj = { <Box<Expr> as FoldWith<V>>::fold_with(obj, visitor) };
-                let prop = { <MemberProp as FoldWith<V>>::fold_with(prop, visitor) };
-                MemberExpr { span, obj, prop }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
+                        self::fields::MemberExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
+                        self::fields::MemberExprField::Obj,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
+                        self::fields::MemberExprField::Prop,
+                    ));
+                    <MemberProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MemberProp {
-    #[doc = "Calls [Fold`::fold_member_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_member_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MemberProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_member_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_member_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MemberProp::Ident { 0: _field_0 } => {
-                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
-                MemberProp::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
+                    self::fields::MemberPropField::Ident,
+                ));
+                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MemberProp::PrivateName { 0: _field_0 } => {
-                let _field_0 = <PrivateName as FoldWith<V>>::fold_with(_field_0, visitor);
-                MemberProp::PrivateName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
+                    self::fields::MemberPropField::PrivateName,
+                ));
+                <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             MemberProp::Computed { 0: _field_0 } => {
-                let _field_0 = <ComputedPropName as FoldWith<V>>::fold_with(_field_0, visitor);
-                MemberProp::Computed { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
+                    self::fields::MemberPropField::Computed,
+                ));
+                <ComputedPropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MetaPropExpr {
-    #[doc = "Calls [Fold`::fold_meta_prop_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_meta_prop_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MetaPropExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_meta_prop_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_meta_prop_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MetaPropExpr { span, kind } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let kind = { <MetaPropKind as FoldWith<V>>::fold_with(kind, visitor) };
-                MetaPropExpr { span, kind }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
+                        self::fields::MetaPropExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
+                        self::fields::MetaPropExprField::Kind,
+                    ));
+                    <MetaPropKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MetaPropKind {
-    #[doc = "Calls [Fold`::fold_meta_prop_kind`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_meta_prop_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MetaPropKind {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_meta_prop_kind`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_meta_prop_kind(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            MetaPropKind::NewTarget => MetaPropKind::NewTarget,
-            MetaPropKind::ImportMeta => MetaPropKind::ImportMeta,
+            MetaPropKind::NewTarget => {}
+            MetaPropKind::ImportMeta => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MethodKind {
-    #[doc = "Calls [Fold`::fold_method_kind`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_method_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MethodKind {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_method_kind`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_method_kind(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            MethodKind::Method => MethodKind::Method,
-            MethodKind::Getter => MethodKind::Getter,
-            MethodKind::Setter => MethodKind::Setter,
+            MethodKind::Method => {}
+            MethodKind::Getter => {}
+            MethodKind::Setter => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for MethodProp {
-    #[doc = "Calls [Fold`::fold_method_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_method_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for MethodProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_method_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_method_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             MethodProp { key, function } => {
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
-                MethodProp { key, function }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
+                        self::fields::MethodPropField::Key,
+                    ));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
+                        self::fields::MethodPropField::Function,
+                    ));
+                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Module {
-    #[doc = "Calls [Fold`::fold_module`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_module(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Module {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_module`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Module {
                 span,
                 body,
                 shebang,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let body = { <Vec<ModuleItem> as FoldWith<V>>::fold_with(body, visitor) };
-                let shebang =
-                    { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(shebang, visitor) };
-                Module {
-                    span,
-                    body,
-                    shebang,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Module(
+                        self::fields::ModuleField::Body(usize::MAX),
+                    ));
+                    <Vec<ModuleItem> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Shebang));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        shebang,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ModuleDecl {
-    #[doc = "Calls [Fold`::fold_module_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_module_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ModuleDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ModuleDecl::Import { 0: _field_0 } => {
-                let _field_0 = <ImportDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::Import { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::Import,
+                ));
+                <ImportDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportDecl { 0: _field_0 } => {
-                let _field_0 = <ExportDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::ExportDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportDecl,
+                ));
+                <ExportDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportNamed { 0: _field_0 } => {
-                let _field_0 = <NamedExport as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::ExportNamed { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportNamed,
+                ));
+                <NamedExport as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportDefaultDecl { 0: _field_0 } => {
-                let _field_0 = <ExportDefaultDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::ExportDefaultDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportDefaultDecl,
+                ));
+                <ExportDefaultDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportDefaultExpr { 0: _field_0 } => {
-                let _field_0 = <ExportDefaultExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::ExportDefaultExpr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportDefaultExpr,
+                ));
+                <ExportDefaultExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::ExportAll { 0: _field_0 } => {
-                let _field_0 = <ExportAll as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::ExportAll { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportAll,
+                ));
+                <ExportAll as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::TsImportEquals { 0: _field_0 } => {
-                let _field_0 =
-                    <Box<TsImportEqualsDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::TsImportEquals { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::TsImportEquals,
+                ));
+                <Box<TsImportEqualsDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::TsExportAssignment { 0: _field_0 } => {
-                let _field_0 = <TsExportAssignment as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::TsExportAssignment { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::TsExportAssignment,
+                ));
+                <TsExportAssignment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleDecl::TsNamespaceExport { 0: _field_0 } => {
-                let _field_0 = <TsNamespaceExportDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleDecl::TsNamespaceExport { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::TsNamespaceExport,
+                ));
+                <TsNamespaceExportDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ModuleExportName {
-    #[doc = "Calls [Fold`::fold_module_export_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_module_export_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ModuleExportName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_export_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_export_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ModuleExportName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleExportName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
+                    self::fields::ModuleExportNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleExportName::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleExportName::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
+                    self::fields::ModuleExportNameField::Str,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ModuleItem {
-    #[doc = "Calls [Fold`::fold_module_item`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_module_item(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ModuleItem {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_item`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_item(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ModuleItem::ModuleDecl { 0: _field_0 } => {
-                let _field_0 = <ModuleDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleItem::ModuleDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
+                    self::fields::ModuleItemField::ModuleDecl,
+                ));
+                <ModuleDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ModuleItem::Stmt { 0: _field_0 } => {
-                let _field_0 = <Stmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                ModuleItem::Stmt { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
+                    self::fields::ModuleItemField::Stmt,
+                ));
+                <Stmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NamedExport {
-    #[doc = "Calls [Fold`::fold_named_export`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_named_export(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NamedExport {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_named_export`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_named_export(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             NamedExport {
                 span,
@@ -105933,29 +84209,59 @@ impl<V: ?Sized + Fold> FoldWith<V> for NamedExport {
                 type_only,
                 with,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let specifiers =
-                    { <Vec<ExportSpecifier> as FoldWith<V>>::fold_with(specifiers, visitor) };
-                let src = { <Option<Box<Str>> as FoldWith<V>>::fold_with(src, visitor) };
-                let with = { <Option<Box<ObjectLit>> as FoldWith<V>>::fold_with(with, visitor) };
-                NamedExport {
-                    span,
-                    specifiers,
-                    src,
-                    type_only,
-                    with,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::Specifiers(usize::MAX),
+                    ));
+                    <Vec<ExportSpecifier> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        specifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::Src,
+                    ));
+                    <Option<Box<Str>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::With,
+                    ));
+                    <Option<Box<ObjectLit>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for NewExpr {
-    #[doc = "Calls [Fold`::fold_new_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_new_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for NewExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_new_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_new_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             NewExpr {
                 span,
@@ -105964,80 +84270,152 @@ impl<V: ?Sized + Fold> FoldWith<V> for NewExpr {
                 args,
                 type_args,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let callee = { <Box<Expr> as FoldWith<V>>::fold_with(callee, visitor) };
-                let args = { <Option<Vec<ExprOrSpread>> as FoldWith<V>>::fold_with(args, visitor) };
-                let type_args = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_args, visitor,
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                NewExpr {
-                    span,
-                    ctxt,
-                    callee,
-                    args,
-                    type_args,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Callee));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NewExpr(
+                        self::fields::NewExprField::Args(usize::MAX),
+                    ));
+                    <Option<Vec<ExprOrSpread>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::TypeArgs));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Null {
-    #[doc = "Calls [Fold`::fold_null`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_null(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Null {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_null`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_null(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Null { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                Null { span }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Null(self::fields::NullField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Number {
-    #[doc = "Calls [Fold`::fold_number`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_number(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Number {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_number`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_number(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Number { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                Number { span, value, raw }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ObjectLit {
-    #[doc = "Calls [Fold`::fold_object_lit`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_object_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ObjectLit {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_lit`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_lit(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ObjectLit { span, props } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let props = { <Vec<PropOrSpread> as FoldWith<V>>::fold_with(props, visitor) };
-                ObjectLit { span, props }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ObjectLit(self::fields::ObjectLitField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectLit(
+                        self::fields::ObjectLitField::Props(usize::MAX),
+                    ));
+                    <Vec<PropOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        props,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ObjectPat {
-    #[doc = "Calls [Fold`::fold_object_pat`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_object_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ObjectPat {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_pat`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_pat(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ObjectPat {
                 span,
@@ -106045,50 +84423,91 @@ impl<V: ?Sized + Fold> FoldWith<V> for ObjectPat {
                 optional,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let props = { <Vec<ObjectPatProp> as FoldWith<V>>::fold_with(props, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                ObjectPat {
-                    span,
-                    props,
-                    optional,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ObjectPat(self::fields::ObjectPatField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
+                        self::fields::ObjectPatField::Props(usize::MAX),
+                    ));
+                    <Vec<ObjectPatProp> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        props,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
+                        self::fields::ObjectPatField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ObjectPatProp {
-    #[doc = "Calls [Fold`::fold_object_pat_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_object_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ObjectPatProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_pat_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_pat_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ObjectPatProp::KeyValue { 0: _field_0 } => {
-                let _field_0 = <KeyValuePatProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                ObjectPatProp::KeyValue { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
+                    self::fields::ObjectPatPropField::KeyValue,
+                ));
+                <KeyValuePatProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ObjectPatProp::Assign { 0: _field_0 } => {
-                let _field_0 = <AssignPatProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                ObjectPatProp::Assign { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
+                    self::fields::ObjectPatPropField::Assign,
+                ));
+                <AssignPatProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ObjectPatProp::Rest { 0: _field_0 } => {
-                let _field_0 = <RestPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                ObjectPatProp::Rest { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
+                    self::fields::ObjectPatPropField::Rest,
+                ));
+                <RestPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for OptCall {
-    #[doc = "Calls [Fold`::fold_opt_call`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_call(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptCall {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_call`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_call(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             OptCall {
                 span,
@@ -106097,176 +84516,322 @@ impl<V: ?Sized + Fold> FoldWith<V> for OptCall {
                 args,
                 type_args,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let callee = { <Box<Expr> as FoldWith<V>>::fold_with(callee, visitor) };
-                let args = { <Vec<ExprOrSpread> as FoldWith<V>>::fold_with(args, visitor) };
-                let type_args = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_args, visitor,
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                OptCall {
-                    span,
-                    ctxt,
-                    callee,
-                    args,
-                    type_args,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Callee));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptCall(
+                        self::fields::OptCallField::Args(usize::MAX),
+                    ));
+                    <Vec<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::TypeArgs));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for OptChainBase {
-    #[doc = "Calls [Fold`::fold_opt_chain_base`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_chain_base(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptChainBase {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_chain_base`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_chain_base(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             OptChainBase::Member { 0: _field_0 } => {
-                let _field_0 = <MemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                OptChainBase::Member { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
+                    self::fields::OptChainBaseField::Member,
+                ));
+                <MemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             OptChainBase::Call { 0: _field_0 } => {
-                let _field_0 = <OptCall as FoldWith<V>>::fold_with(_field_0, visitor);
-                OptChainBase::Call { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
+                    self::fields::OptChainBaseField::Call,
+                ));
+                <OptCall as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for OptChainExpr {
-    #[doc = "Calls [Fold`::fold_opt_chain_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_chain_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for OptChainExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_chain_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_chain_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             OptChainExpr {
                 span,
                 optional,
                 base,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let base = { <Box<OptChainBase> as FoldWith<V>>::fold_with(base, visitor) };
-                OptChainExpr {
-                    span,
-                    optional,
-                    base,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
+                        self::fields::OptChainExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
+                        self::fields::OptChainExprField::Base,
+                    ));
+                    <Box<OptChainBase> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        base,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Param {
-    #[doc = "Calls [Fold`::fold_param`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Param {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_param`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_param(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Param {
                 span,
                 decorators,
                 pat,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let decorators =
-                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
-                let pat = { <Pat as FoldWith<V>>::fold_with(pat, visitor) };
-                Param {
-                    span,
-                    decorators,
-                    pat,
-                }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Param(
+                        self::fields::ParamField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Pat));
+                    <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        pat,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ParamOrTsParamProp {
-    #[doc = "Calls [Fold`::fold_param_or_ts_param_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_param_or_ts_param_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ParamOrTsParamProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_param_or_ts_param_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ParamOrTsParamProp::TsParamProp { 0: _field_0 } => {
-                let _field_0 = <TsParamProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                ParamOrTsParamProp::TsParamProp { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
+                    self::fields::ParamOrTsParamPropField::TsParamProp,
+                ));
+                <TsParamProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             ParamOrTsParamProp::Param { 0: _field_0 } => {
-                let _field_0 = <Param as FoldWith<V>>::fold_with(_field_0, visitor);
-                ParamOrTsParamProp::Param { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
+                    self::fields::ParamOrTsParamPropField::Param,
+                ));
+                <Param as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ParenExpr {
-    #[doc = "Calls [Fold`::fold_paren_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_paren_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ParenExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_paren_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_paren_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ParenExpr { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                ParenExpr { span, expr }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Expr));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Pat {
-    #[doc = "Calls [Fold`::fold_pat`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Pat {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pat`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pat(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Pat::Ident { 0: _field_0 } => {
-                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                Pat::Ident { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Ident));
+                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Array { 0: _field_0 } => {
-                let _field_0 = <ArrayPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                Pat::Array { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Array));
+                <ArrayPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Rest { 0: _field_0 } => {
-                let _field_0 = <RestPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                Pat::Rest { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Rest));
+                <RestPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Object { 0: _field_0 } => {
-                let _field_0 = <ObjectPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                Pat::Object { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Object));
+                <ObjectPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Assign { 0: _field_0 } => {
-                let _field_0 = <AssignPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                Pat::Assign { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Assign));
+                <AssignPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Invalid { 0: _field_0 } => {
-                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
-                Pat::Invalid { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Invalid));
+                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Pat::Expr { 0: _field_0 } => {
-                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Pat::Expr { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Expr));
+                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PrivateMethod {
-    #[doc = "Calls [Fold`::fold_private_method`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_private_method(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateMethod {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_private_method`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_method(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PrivateMethod {
                 span,
@@ -106279,50 +84844,104 @@ impl<V: ?Sized + Fold> FoldWith<V> for PrivateMethod {
                 is_optional,
                 is_override,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <PrivateName as FoldWith<V>>::fold_with(key, visitor) };
-                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
-                let kind = { <MethodKind as FoldWith<V>>::fold_with(kind, visitor) };
-                let accessibility =
-                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
-                PrivateMethod {
-                    span,
-                    key,
-                    function,
-                    kind,
-                    is_static,
-                    accessibility,
-                    is_abstract,
-                    is_optional,
-                    is_override,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Key,
+                    ));
+                    <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Function,
+                    ));
+                    <Box<Function> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Kind,
+                    ));
+                    <MethodKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PrivateName {
-    #[doc = "Calls [Fold`::fold_private_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_private_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_private_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PrivateName { span, name } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <swc_atoms::Atom as FoldWith<V>>::fold_with(name, visitor) };
-                PrivateName { span, name }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
+                        self::fields::PrivateNameField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
+                        self::fields::PrivateNameField::Name,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PrivateProp {
-    #[doc = "Calls [Fold`::fold_private_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_private_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PrivateProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_private_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_private_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PrivateProp {
                 span,
@@ -106338,162 +84957,321 @@ impl<V: ?Sized + Fold> FoldWith<V> for PrivateProp {
                 readonly,
                 definite,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let key = { <PrivateName as FoldWith<V>>::fold_with(key, visitor) };
-                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let decorators =
-                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
-                let accessibility =
-                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
-                PrivateProp {
-                    span,
-                    ctxt,
-                    key,
-                    value,
-                    type_ann,
-                    is_static,
-                    decorators,
-                    accessibility,
-                    is_optional,
-                    is_override,
-                    readonly,
-                    definite,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Key,
+                    ));
+                    <PrivateName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Value,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Program {
-    #[doc = "Calls [Fold`::fold_program`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_program(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Program {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_program`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_program(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Program::Module { 0: _field_0 } => {
-                let _field_0 = <Module as FoldWith<V>>::fold_with(_field_0, visitor);
-                Program::Module { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Module));
+                <Module as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Program::Script { 0: _field_0 } => {
-                let _field_0 = <Script as FoldWith<V>>::fold_with(_field_0, visitor);
-                Program::Script { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Script));
+                <Script as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Prop {
-    #[doc = "Calls [Fold`::fold_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Prop {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Prop::Shorthand { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                Prop::Shorthand { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Shorthand));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::KeyValue { 0: _field_0 } => {
-                let _field_0 = <KeyValueProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                Prop::KeyValue { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::KeyValue));
+                <KeyValueProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Assign { 0: _field_0 } => {
-                let _field_0 = <AssignProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                Prop::Assign { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Assign));
+                <AssignProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Getter { 0: _field_0 } => {
-                let _field_0 = <GetterProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                Prop::Getter { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Getter));
+                <GetterProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Setter { 0: _field_0 } => {
-                let _field_0 = <SetterProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                Prop::Setter { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Setter));
+                <SetterProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Prop::Method { 0: _field_0 } => {
-                let _field_0 = <MethodProp as FoldWith<V>>::fold_with(_field_0, visitor);
-                Prop::Method { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Method));
+                <MethodProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PropName {
-    #[doc = "Calls [Fold`::fold_prop_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_prop_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PropName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PropName::Ident { 0: _field_0 } => {
-                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
-                PropName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Ident));
+                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                PropName::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Str));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::Num { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                PropName::Num { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Num));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::Computed { 0: _field_0 } => {
-                let _field_0 = <ComputedPropName as FoldWith<V>>::fold_with(_field_0, visitor);
-                PropName::Computed { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropName(
+                    self::fields::PropNameField::Computed,
+                ));
+                <ComputedPropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropName::BigInt { 0: _field_0 } => {
-                let _field_0 = <BigInt as FoldWith<V>>::fold_with(_field_0, visitor);
-                PropName::BigInt { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::BigInt));
+                <BigInt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for PropOrSpread {
-    #[doc = "Calls [Fold`::fold_prop_or_spread`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_prop_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for PropOrSpread {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop_or_spread`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop_or_spread(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             PropOrSpread::Spread { 0: _field_0 } => {
-                let _field_0 = <SpreadElement as FoldWith<V>>::fold_with(_field_0, visitor);
-                PropOrSpread::Spread { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
+                    self::fields::PropOrSpreadField::Spread,
+                ));
+                <SpreadElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             PropOrSpread::Prop { 0: _field_0 } => {
-                let _field_0 = <Box<Prop> as FoldWith<V>>::fold_with(_field_0, visitor);
-                PropOrSpread::Prop { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
+                    self::fields::PropOrSpreadField::Prop,
+                ));
+                <Box<Prop> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Regex {
-    #[doc = "Calls [Fold`::fold_regex`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_regex(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Regex {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_regex`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_regex(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Regex { span, exp, flags } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let exp = { <swc_atoms::Atom as FoldWith<V>>::fold_with(exp, visitor) };
-                let flags = { <swc_atoms::Atom as FoldWith<V>>::fold_with(flags, visitor) };
-                Regex { span, exp, flags }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Exp));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        exp,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Regex(self::fields::RegexField::Flags));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        flags,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for RestPat {
-    #[doc = "Calls [Fold`::fold_rest_pat`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_rest_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for RestPat {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_rest_pat`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_rest_pat(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             RestPat {
                 span,
@@ -106501,87 +85279,172 @@ impl<V: ?Sized + Fold> FoldWith<V> for RestPat {
                 arg,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let dot3_token =
-                    { <swc_common::Span as FoldWith<V>>::fold_with(dot3_token, visitor) };
-                let arg = { <Box<Pat> as FoldWith<V>>::fold_with(arg, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                RestPat {
-                    span,
-                    dot3_token,
-                    arg,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RestPat(
+                        self::fields::RestPatField::Dot3Token,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        dot3_token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Arg));
+                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::TypeAnn));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ReturnStmt {
-    #[doc = "Calls [Fold`::fold_return_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_return_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ReturnStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_return_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_return_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ReturnStmt { span, arg } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let arg = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(arg, visitor) };
-                ReturnStmt { span, arg }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
+                        self::fields::ReturnStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
+                        self::fields::ReturnStmtField::Arg,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Script {
-    #[doc = "Calls [Fold`::fold_script`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_script(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Script {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_script`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_script(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Script {
                 span,
                 body,
                 shebang,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let body = { <Vec<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                let shebang =
-                    { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(shebang, visitor) };
-                Script {
-                    span,
-                    body,
-                    shebang,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Script(
+                        self::fields::ScriptField::Body(usize::MAX),
+                    ));
+                    <Vec<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Shebang));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        shebang,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SeqExpr {
-    #[doc = "Calls [Fold`::fold_seq_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_seq_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SeqExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_seq_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_seq_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SeqExpr { span, exprs } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let exprs = { <Vec<Box<Expr>> as FoldWith<V>>::fold_with(exprs, visitor) };
-                SeqExpr { span, exprs }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::SeqExpr(self::fields::SeqExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SeqExpr(
+                        self::fields::SeqExprField::Exprs(usize::MAX),
+                    ));
+                    <Vec<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        exprs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SetterProp {
-    #[doc = "Calls [Fold`::fold_setter_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_setter_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SetterProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_setter_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_setter_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SetterProp {
                 span,
@@ -106590,314 +85453,684 @@ impl<V: ?Sized + Fold> FoldWith<V> for SetterProp {
                 param,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
-                let this_param = { <Option<Pat> as FoldWith<V>>::fold_with(this_param, visitor) };
-                let param = { <Box<Pat> as FoldWith<V>>::fold_with(param, visitor) };
-                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
-                SetterProp {
-                    span,
-                    key,
-                    this_param,
-                    param,
-                    body,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Key,
+                    ));
+                    <PropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::ThisParam,
+                    ));
+                    <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        this_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Param,
+                    ));
+                    <Box<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Body,
+                    ));
+                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SimpleAssignTarget {
-    #[doc = "Calls [Fold`::fold_simple_assign_target`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_simple_assign_target(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SimpleAssignTarget {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_simple_assign_target`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_simple_assign_target(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SimpleAssignTarget::Ident { 0: _field_0 } => {
-                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Ident,
+                ));
+                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::Member { 0: _field_0 } => {
-                let _field_0 = <MemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::Member { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Member,
+                ));
+                <MemberExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::SuperProp { 0: _field_0 } => {
-                let _field_0 = <SuperPropExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::SuperProp { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::SuperProp,
+                ));
+                <SuperPropExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::Paren { 0: _field_0 } => {
-                let _field_0 = <ParenExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::Paren { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Paren,
+                ));
+                <ParenExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::OptChain { 0: _field_0 } => {
-                let _field_0 = <OptChainExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::OptChain { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::OptChain,
+                ));
+                <OptChainExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsAs { 0: _field_0 } => {
-                let _field_0 = <TsAsExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::TsAs { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsAs,
+                ));
+                <TsAsExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsSatisfies { 0: _field_0 } => {
-                let _field_0 = <TsSatisfiesExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::TsSatisfies { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsSatisfies,
+                ));
+                <TsSatisfiesExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsNonNull { 0: _field_0 } => {
-                let _field_0 = <TsNonNullExpr as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::TsNonNull { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsNonNull,
+                ));
+                <TsNonNullExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsTypeAssertion { 0: _field_0 } => {
-                let _field_0 = <TsTypeAssertion as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::TsTypeAssertion { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsTypeAssertion,
+                ));
+                <TsTypeAssertion as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::TsInstantiation { 0: _field_0 } => {
-                let _field_0 = <TsInstantiation as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::TsInstantiation { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsInstantiation,
+                ));
+                <TsInstantiation as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SimpleAssignTarget::Invalid { 0: _field_0 } => {
-                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
-                SimpleAssignTarget::Invalid { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Invalid,
+                ));
+                <Invalid as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SpreadElement {
-    #[doc = "Calls [Fold`::fold_spread_element`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_spread_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SpreadElement {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_spread_element`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_spread_element(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SpreadElement { dot3_token, expr } => {
-                let dot3_token =
-                    { <swc_common::Span as FoldWith<V>>::fold_with(dot3_token, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                SpreadElement { dot3_token, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
+                        self::fields::SpreadElementField::Dot3Token,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        dot3_token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
+                        self::fields::SpreadElementField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for StaticBlock {
-    #[doc = "Calls [Fold`::fold_static_block`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_static_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for StaticBlock {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_static_block`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_static_block(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             StaticBlock { span, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let body = { <BlockStmt as FoldWith<V>>::fold_with(body, visitor) };
-                StaticBlock { span, body }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
+                        self::fields::StaticBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
+                        self::fields::StaticBlockField::Body,
+                    ));
+                    <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Stmt {
-    #[doc = "Calls [Fold`::fold_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Stmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Stmt::Block { 0: _field_0 } => {
-                let _field_0 = <BlockStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Block { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Block));
+                <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Empty { 0: _field_0 } => {
-                let _field_0 = <EmptyStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Empty { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Empty));
+                <EmptyStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Debugger { 0: _field_0 } => {
-                let _field_0 = <DebuggerStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Debugger { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Debugger));
+                <DebuggerStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::With { 0: _field_0 } => {
-                let _field_0 = <WithStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::With { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::With));
+                <WithStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Return { 0: _field_0 } => {
-                let _field_0 = <ReturnStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Return { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Return));
+                <ReturnStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Labeled { 0: _field_0 } => {
-                let _field_0 = <LabeledStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Labeled { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Labeled));
+                <LabeledStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Break { 0: _field_0 } => {
-                let _field_0 = <BreakStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Break { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Break));
+                <BreakStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Continue { 0: _field_0 } => {
-                let _field_0 = <ContinueStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Continue { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Continue));
+                <ContinueStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::If { 0: _field_0 } => {
-                let _field_0 = <IfStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::If { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::If));
+                <IfStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Switch { 0: _field_0 } => {
-                let _field_0 = <SwitchStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Switch { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Switch));
+                <SwitchStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Throw { 0: _field_0 } => {
-                let _field_0 = <ThrowStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Throw { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Throw));
+                <ThrowStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Try { 0: _field_0 } => {
-                let _field_0 = <Box<TryStmt> as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Try { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Try));
+                <Box<TryStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::While { 0: _field_0 } => {
-                let _field_0 = <WhileStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::While { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::While));
+                <WhileStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::DoWhile { 0: _field_0 } => {
-                let _field_0 = <DoWhileStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::DoWhile { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::DoWhile));
+                <DoWhileStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::For { 0: _field_0 } => {
-                let _field_0 = <ForStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::For { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::For));
+                <ForStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::ForIn { 0: _field_0 } => {
-                let _field_0 = <ForInStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::ForIn { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForIn));
+                <ForInStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::ForOf { 0: _field_0 } => {
-                let _field_0 = <ForOfStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::ForOf { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForOf));
+                <ForOfStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Decl { 0: _field_0 } => {
-                let _field_0 = <Decl as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Decl { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Decl));
+                <Decl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             Stmt::Expr { 0: _field_0 } => {
-                let _field_0 = <ExprStmt as FoldWith<V>>::fold_with(_field_0, visitor);
-                Stmt::Expr { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Expr));
+                <ExprStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Str {
-    #[doc = "Calls [Fold`::fold_str`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_str(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Str {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_str`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_str(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Str { span, value, raw } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
-                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
-                Str { span, value, raw }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Super {
-    #[doc = "Calls [Fold`::fold_super`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_super(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Super {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_super`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_super(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Super { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                Super { span }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Super(self::fields::SuperField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SuperProp {
-    #[doc = "Calls [Fold`::fold_super_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_super_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SuperProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_super_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_super_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SuperProp::Ident { 0: _field_0 } => {
-                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
-                SuperProp::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
+                    self::fields::SuperPropField::Ident,
+                ));
+                <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             SuperProp::Computed { 0: _field_0 } => {
-                let _field_0 = <ComputedPropName as FoldWith<V>>::fold_with(_field_0, visitor);
-                SuperProp::Computed { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
+                    self::fields::SuperPropField::Computed,
+                ));
+                <ComputedPropName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SuperPropExpr {
-    #[doc = "Calls [Fold`::fold_super_prop_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_super_prop_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SuperPropExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_super_prop_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_super_prop_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SuperPropExpr { span, obj, prop } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let obj = { <Super as FoldWith<V>>::fold_with(obj, visitor) };
-                let prop = { <SuperProp as FoldWith<V>>::fold_with(prop, visitor) };
-                SuperPropExpr { span, obj, prop }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
+                        self::fields::SuperPropExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
+                        self::fields::SuperPropExprField::Obj,
+                    ));
+                    <Super as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
+                        self::fields::SuperPropExprField::Prop,
+                    ));
+                    <SuperProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SwitchCase {
-    #[doc = "Calls [Fold`::fold_switch_case`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_switch_case(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SwitchCase {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_switch_case`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_case(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             SwitchCase { span, test, cons } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let test = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(test, visitor) };
-                let cons = { <Vec<Stmt> as FoldWith<V>>::fold_with(cons, visitor) };
-                SwitchCase { span, test, cons }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
+                        self::fields::SwitchCaseField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
+                        self::fields::SwitchCaseField::Test,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
+                        self::fields::SwitchCaseField::Cons(usize::MAX),
+                    ));
+                    <Vec<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for SwitchStmt {
-    #[doc = "Calls [Fold`::fold_switch_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_switch_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for SwitchStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_switch_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        match self {
-            SwitchStmt {
-                span,
-                discriminant,
-                cases,
-            } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let discriminant = { <Box<Expr> as FoldWith<V>>::fold_with(discriminant, visitor) };
-                let cases = { <Vec<SwitchCase> as FoldWith<V>>::fold_with(cases, visitor) };
-                SwitchStmt {
-                    span,
-                    discriminant,
-                    cases,
-                }
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            SwitchStmt {
+                span,
+                discriminant,
+                cases,
+            } => {
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
+                        self::fields::SwitchStmtField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
+                        self::fields::SwitchStmtField::Discriminant,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        discriminant,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
+                        self::fields::SwitchStmtField::Cases(usize::MAX),
+                    ));
+                    <Vec<SwitchCase> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        cases,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TaggedTpl {
-    #[doc = "Calls [Fold`::fold_tagged_tpl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_tagged_tpl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TaggedTpl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_tagged_tpl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tagged_tpl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TaggedTpl {
                 span,
@@ -106906,90 +86139,166 @@ impl<V: ?Sized + Fold> FoldWith<V> for TaggedTpl {
                 type_params,
                 tpl,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let tag = { <Box<Expr> as FoldWith<V>>::fold_with(tag, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_params,
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
                         visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tag));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        tag,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TaggedTpl(
+                        self::fields::TaggedTplField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tpl));
+                    <Box<Tpl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        tpl,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                let tpl = { <Box<Tpl> as FoldWith<V>>::fold_with(tpl, visitor) };
-                TaggedTpl {
-                    span,
-                    ctxt,
-                    tag,
-                    type_params,
-                    tpl,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ThisExpr {
-    #[doc = "Calls [Fold`::fold_this_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_this_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ThisExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_this_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_this_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ThisExpr { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                ThisExpr { span }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ThisExpr(self::fields::ThisExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for ThrowStmt {
-    #[doc = "Calls [Fold`::fold_throw_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_throw_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for ThrowStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_throw_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_throw_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             ThrowStmt { span, arg } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
-                ThrowStmt { span, arg }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Arg));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Tpl {
-    #[doc = "Calls [Fold`::fold_tpl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_tpl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Tpl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_tpl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Tpl {
                 span,
                 exprs,
                 quasis,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let exprs = { <Vec<Box<Expr>> as FoldWith<V>>::fold_with(exprs, visitor) };
-                let quasis = { <Vec<TplElement> as FoldWith<V>>::fold_with(quasis, visitor) };
-                Tpl {
-                    span,
-                    exprs,
-                    quasis,
-                }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Tpl(self::fields::TplField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
+                        self::fields::TplField::Exprs(usize::MAX),
+                    ));
+                    <Vec<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        exprs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
+                        self::fields::TplField::Quasis(usize::MAX),
+                    ));
+                    <Vec<TplElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        quasis,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TplElement {
-    #[doc = "Calls [Fold`::fold_tpl_element`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_tpl_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TplElement {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_tpl_element`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl_element(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TplElement {
                 span,
@@ -106997,41 +86306,65 @@ impl<V: ?Sized + Fold> FoldWith<V> for TplElement {
                 cooked,
                 raw,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let cooked =
-                    { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(cooked, visitor) };
-                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
-                TplElement {
-                    span,
-                    tail,
-                    cooked,
-                    raw,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
+                        self::fields::TplElementField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
+                        self::fields::TplElementField::Cooked,
+                    ));
+                    <Option<swc_atoms::Atom> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        cooked,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
+                        self::fields::TplElementField::Raw,
+                    ));
+                    <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TruePlusMinus {
-    #[doc = "Calls [Fold`::fold_true_plus_minus`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_true_plus_minus(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TruePlusMinus {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_true_plus_minus`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_true_plus_minus(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            TruePlusMinus::True => TruePlusMinus::True,
-            TruePlusMinus::Plus => TruePlusMinus::Plus,
-            TruePlusMinus::Minus => TruePlusMinus::Minus,
+            TruePlusMinus::True => {}
+            TruePlusMinus::Plus => {}
+            TruePlusMinus::Minus => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TryStmt {
-    #[doc = "Calls [Fold`::fold_try_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_try_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TryStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_try_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_try_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TryStmt {
                 span,
@@ -107039,69 +86372,138 @@ impl<V: ?Sized + Fold> FoldWith<V> for TryStmt {
                 handler,
                 finalizer,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let block = { <BlockStmt as FoldWith<V>>::fold_with(block, visitor) };
-                let handler = { <Option<CatchClause> as FoldWith<V>>::fold_with(handler, visitor) };
-                let finalizer =
-                    { <Option<BlockStmt> as FoldWith<V>>::fold_with(finalizer, visitor) };
-                TryStmt {
-                    span,
-                    block,
-                    handler,
-                    finalizer,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Block));
+                    <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Handler));
+                    <Option<CatchClause> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        handler,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TryStmt(
+                        self::fields::TryStmtField::Finalizer,
+                    ));
+                    <Option<BlockStmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        finalizer,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsArrayType {
-    #[doc = "Calls [Fold`::fold_ts_array_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_array_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsArrayType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_array_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_array_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsArrayType { span, elem_type } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let elem_type = { <Box<TsType> as FoldWith<V>>::fold_with(elem_type, visitor) };
-                TsArrayType { span, elem_type }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
+                        self::fields::TsArrayTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
+                        self::fields::TsArrayTypeField::ElemType,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        elem_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsAsExpr {
-    #[doc = "Calls [Fold`::fold_ts_as_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_as_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsAsExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_as_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_as_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsAsExpr {
                 span,
                 expr,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsAsExpr {
-                    span,
-                    expr,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Expr));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsAsExpr(
+                        self::fields::TsAsExprField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsCallSignatureDecl {
-    #[doc = "Calls [Fold`::fold_ts_call_signature_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_call_signature_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsCallSignatureDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_call_signature_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_call_signature_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsCallSignatureDecl {
                 span,
@@ -107109,30 +86511,55 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsCallSignatureDecl {
                 type_ann,
                 type_params,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
                 };
-                TsCallSignatureDecl {
-                    span,
-                    params,
-                    type_ann,
-                    type_params,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsConditionalType {
-    #[doc = "Calls [Fold`::fold_ts_conditional_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_conditional_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConditionalType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_conditional_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_conditional_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsConditionalType {
                 span,
@@ -107141,46 +86568,104 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsConditionalType {
                 true_type,
                 false_type,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let check_type = { <Box<TsType> as FoldWith<V>>::fold_with(check_type, visitor) };
-                let extends_type =
-                    { <Box<TsType> as FoldWith<V>>::fold_with(extends_type, visitor) };
-                let true_type = { <Box<TsType> as FoldWith<V>>::fold_with(true_type, visitor) };
-                let false_type = { <Box<TsType> as FoldWith<V>>::fold_with(false_type, visitor) };
-                TsConditionalType {
-                    span,
-                    check_type,
-                    extends_type,
-                    true_type,
-                    false_type,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::CheckType,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        check_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::ExtendsType,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        extends_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::TrueType,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        true_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::FalseType,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        false_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsConstAssertion {
-    #[doc = "Calls [Fold`::fold_ts_const_assertion`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_const_assertion(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstAssertion {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_const_assertion`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_const_assertion(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsConstAssertion { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                TsConstAssertion { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
+                        self::fields::TsConstAssertionField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
+                        self::fields::TsConstAssertionField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsConstructSignatureDecl {
-    #[doc = "Calls [Fold`::fold_ts_construct_signature_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_construct_signature_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstructSignatureDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_construct_signature_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_construct_signature_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsConstructSignatureDecl {
                 span,
@@ -107188,30 +86673,59 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsConstructSignatureDecl {
                 type_ann,
                 type_params,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::Params(usize::MAX),
+                        ));
+                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::TypeAnn,
+                        ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::TypeParams,
+                        ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
                 };
-                TsConstructSignatureDecl {
-                    span,
-                    params,
-                    type_ann,
-                    type_params,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsConstructorType {
-    #[doc = "Calls [Fold`::fold_ts_constructor_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_constructor_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsConstructorType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_constructor_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_constructor_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsConstructorType {
                 span,
@@ -107220,49 +86734,88 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsConstructorType {
                 type_ann,
                 is_abstract,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::TypeAnn,
+                    ));
+                    <Box<TsTypeAnn> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let type_ann = { <Box<TsTypeAnn> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsConstructorType {
-                    span,
-                    params,
-                    type_params,
-                    type_ann,
-                    is_abstract,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsEntityName {
-    #[doc = "Calls [Fold`::fold_ts_entity_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_entity_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEntityName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_entity_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_entity_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsEntityName::TsQualifiedName { 0: _field_0 } => {
-                let _field_0 = <Box<TsQualifiedName> as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsEntityName::TsQualifiedName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
+                    self::fields::TsEntityNameField::TsQualifiedName,
+                ));
+                <Box<TsQualifiedName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsEntityName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsEntityName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
+                    self::fields::TsEntityNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsEnumDecl {
-    #[doc = "Calls [Fold`::fold_ts_enum_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_enum_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEnumDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsEnumDecl {
                 span,
@@ -107271,170 +86824,326 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsEnumDecl {
                 id,
                 members,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
-                let members = { <Vec<TsEnumMember> as FoldWith<V>>::fold_with(members, visitor) };
-                TsEnumDecl {
-                    span,
-                    declare,
-                    is_const,
-                    id,
-                    members,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
+                        self::fields::TsEnumDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsEnumDecl(self::fields::TsEnumDeclField::Id));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
+                        self::fields::TsEnumDeclField::Members(usize::MAX),
+                    ));
+                    <Vec<TsEnumMember> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        members,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsEnumMember {
-    #[doc = "Calls [Fold`::fold_ts_enum_member`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_enum_member(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEnumMember {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_member`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_member(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsEnumMember { span, id, init } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <TsEnumMemberId as FoldWith<V>>::fold_with(id, visitor) };
-                let init = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(init, visitor) };
-                TsEnumMember { span, id, init }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
+                        self::fields::TsEnumMemberField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
+                        self::fields::TsEnumMemberField::Id,
+                    ));
+                    <TsEnumMemberId as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
+                        self::fields::TsEnumMemberField::Init,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsEnumMemberId {
-    #[doc = "Calls [Fold`::fold_ts_enum_member_id`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_enum_member_id(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsEnumMemberId {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_member_id`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_member_id(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsEnumMemberId::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsEnumMemberId::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
+                    self::fields::TsEnumMemberIdField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsEnumMemberId::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsEnumMemberId::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
+                    self::fields::TsEnumMemberIdField::Str,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsExportAssignment {
-    #[doc = "Calls [Fold`::fold_ts_export_assignment`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_export_assignment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsExportAssignment {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_export_assignment`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_export_assignment(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsExportAssignment { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                TsExportAssignment { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
+                        self::fields::TsExportAssignmentField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
+                        self::fields::TsExportAssignmentField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsExprWithTypeArgs {
-    #[doc = "Calls [Fold`::fold_ts_expr_with_type_args`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_expr_with_type_args(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsExprWithTypeArgs {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_expr_with_type_args`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_args(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsExprWithTypeArgs {
                 span,
                 expr,
                 type_args,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                let type_args = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_args, visitor,
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
+                        self::fields::TsExprWithTypeArgsField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                TsExprWithTypeArgs {
-                    span,
-                    expr,
-                    type_args,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
+                        self::fields::TsExprWithTypeArgsField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
+                        self::fields::TsExprWithTypeArgsField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsExternalModuleRef {
-    #[doc = "Calls [Fold`::fold_ts_external_module_ref`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_external_module_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsExternalModuleRef {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_external_module_ref`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_external_module_ref(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsExternalModuleRef { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Str as FoldWith<V>>::fold_with(expr, visitor) };
-                TsExternalModuleRef { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
+                        self::fields::TsExternalModuleRefField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
+                        self::fields::TsExternalModuleRefField::Expr,
+                    ));
+                    <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsFnOrConstructorType {
-    #[doc = "Calls [Fold`::fold_ts_fn_or_constructor_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_fn_or_constructor_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsFnOrConstructorType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_or_constructor_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_or_constructor_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsFnOrConstructorType::TsFnType { 0: _field_0 } => {
-                let _field_0 = <TsFnType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsFnOrConstructorType::TsFnType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
+                    self::fields::TsFnOrConstructorTypeField::TsFnType,
+                ));
+                <TsFnType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnOrConstructorType::TsConstructorType { 0: _field_0 } => {
-                let _field_0 = <TsConstructorType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsFnOrConstructorType::TsConstructorType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
+                    self::fields::TsFnOrConstructorTypeField::TsConstructorType,
+                ));
+                <TsConstructorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsFnParam {
-    #[doc = "Calls [Fold`::fold_ts_fn_param`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_fn_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsFnParam {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_param`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_param(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsFnParam::Ident { 0: _field_0 } => {
-                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsFnParam::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
+                    self::fields::TsFnParamField::Ident,
+                ));
+                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnParam::Array { 0: _field_0 } => {
-                let _field_0 = <ArrayPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsFnParam::Array { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
+                    self::fields::TsFnParamField::Array,
+                ));
+                <ArrayPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnParam::Rest { 0: _field_0 } => {
-                let _field_0 = <RestPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsFnParam::Rest { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsFnParam(self::fields::TsFnParamField::Rest));
+                <RestPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsFnParam::Object { 0: _field_0 } => {
-                let _field_0 = <ObjectPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsFnParam::Object { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
+                    self::fields::TsFnParamField::Object,
+                ));
+                <ObjectPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsFnType {
-    #[doc = "Calls [Fold`::fold_ts_fn_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_fn_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsFnType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsFnType {
                 span,
@@ -107442,29 +87151,54 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsFnType {
                 type_params,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsFnType(self::fields::TsFnTypeField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
+                        self::fields::TsFnTypeField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
+                        self::fields::TsFnTypeField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
+                        self::fields::TsFnTypeField::TypeAnn,
+                    ));
+                    <Box<TsTypeAnn> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let type_ann = { <Box<TsTypeAnn> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsFnType {
-                    span,
-                    params,
-                    type_params,
-                    type_ann,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsGetterSignature {
-    #[doc = "Calls [Fold`::fold_ts_getter_signature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_getter_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsGetterSignature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_getter_signature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_getter_signature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsGetterSignature {
                 span,
@@ -107472,27 +87206,49 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsGetterSignature {
                 computed,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsGetterSignature {
-                    span,
-                    key,
-                    computed,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
+                        self::fields::TsGetterSignatureField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
+                        self::fields::TsGetterSignatureField::Key,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
+                        self::fields::TsGetterSignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsImportEqualsDecl {
-    #[doc = "Calls [Fold`::fold_ts_import_equals_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_import_equals_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsImportEqualsDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_import_equals_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_import_equals_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsImportEqualsDecl {
                 span,
@@ -107501,27 +87257,49 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsImportEqualsDecl {
                 id,
                 module_ref,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
-                let module_ref = { <TsModuleRef as FoldWith<V>>::fold_with(module_ref, visitor) };
-                TsImportEqualsDecl {
-                    span,
-                    is_export,
-                    is_type_only,
-                    id,
-                    module_ref,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
+                        self::fields::TsImportEqualsDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
+                        self::fields::TsImportEqualsDeclField::Id,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
+                        self::fields::TsImportEqualsDeclField::ModuleRef,
+                    ));
+                    <TsModuleRef as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        module_ref,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsImportType {
-    #[doc = "Calls [Fold`::fold_ts_import_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_import_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsImportType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_import_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_import_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsImportType {
                 span,
@@ -107529,32 +87307,55 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsImportType {
                 qualifier,
                 type_args,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let arg = { <Str as FoldWith<V>>::fold_with(arg, visitor) };
-                let qualifier =
-                    { <Option<TsEntityName> as FoldWith<V>>::fold_with(qualifier, visitor) };
-                let type_args = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_args, visitor,
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                TsImportType {
-                    span,
-                    arg,
-                    qualifier,
-                    type_args,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::Arg,
+                    ));
+                    <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::Qualifier,
+                    ));
+                    <Option<TsEntityName> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        qualifier,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsIndexSignature {
-    #[doc = "Calls [Fold`::fold_ts_index_signature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_index_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIndexSignature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_index_signature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_index_signature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsIndexSignature {
                 params,
@@ -107563,28 +87364,49 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsIndexSignature {
                 is_static,
                 span,
             } => {
-                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                TsIndexSignature {
-                    params,
-                    type_ann,
-                    readonly,
-                    is_static,
-                    span,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
+                        self::fields::TsIndexSignatureField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
+                        self::fields::TsIndexSignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
+                        self::fields::TsIndexSignatureField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsIndexedAccessType {
-    #[doc = "Calls [Fold`::fold_ts_indexed_access_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_indexed_access_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIndexedAccessType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_indexed_access_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_indexed_access_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsIndexedAccessType {
                 span,
@@ -107592,85 +87414,164 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsIndexedAccessType {
                 obj_type,
                 index_type,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let obj_type = { <Box<TsType> as FoldWith<V>>::fold_with(obj_type, visitor) };
-                let index_type = { <Box<TsType> as FoldWith<V>>::fold_with(index_type, visitor) };
-                TsIndexedAccessType {
-                    span,
-                    readonly,
-                    obj_type,
-                    index_type,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
+                        self::fields::TsIndexedAccessTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
+                        self::fields::TsIndexedAccessTypeField::ObjType,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        obj_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
+                        self::fields::TsIndexedAccessTypeField::IndexType,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        index_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsInferType {
-    #[doc = "Calls [Fold`::fold_ts_infer_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_infer_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInferType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_infer_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_infer_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsInferType { span, type_param } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let type_param = { <TsTypeParam as FoldWith<V>>::fold_with(type_param, visitor) };
-                TsInferType { span, type_param }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
+                        self::fields::TsInferTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
+                        self::fields::TsInferTypeField::TypeParam,
+                    ));
+                    <TsTypeParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsInstantiation {
-    #[doc = "Calls [Fold`::fold_ts_instantiation`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_instantiation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInstantiation {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_instantiation`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_instantiation(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsInstantiation {
                 span,
                 expr,
                 type_args,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                let type_args = {
-                    <Box<TsTypeParamInstantiation> as FoldWith<V>>::fold_with(type_args, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
+                        self::fields::TsInstantiationField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
+                        self::fields::TsInstantiationField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
+                        self::fields::TsInstantiationField::TypeArgs,
+                    ));
+                    < Box < TsTypeParamInstantiation > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
                 };
-                TsInstantiation {
-                    span,
-                    expr,
-                    type_args,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsInterfaceBody {
-    #[doc = "Calls [Fold`::fold_ts_interface_body`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_interface_body(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInterfaceBody {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_interface_body`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_interface_body(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsInterfaceBody { span, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let body = { <Vec<TsTypeElement> as FoldWith<V>>::fold_with(body, visitor) };
-                TsInterfaceBody { span, body }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
+                        self::fields::TsInterfaceBodyField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
+                        self::fields::TsInterfaceBodyField::Body(usize::MAX),
+                    ));
+                    <Vec<TsTypeElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsInterfaceDecl {
-    #[doc = "Calls [Fold`::fold_ts_interface_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_interface_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsInterfaceDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_interface_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_interface_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsInterfaceDecl {
                 span,
@@ -107680,136 +87581,252 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsInterfaceDecl {
                 extends,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Id,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Extends(usize::MAX),
+                    ));
+                    <Vec<TsExprWithTypeArgs> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        extends,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Body,
+                    ));
+                    <TsInterfaceBody as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let extends =
-                    { <Vec<TsExprWithTypeArgs> as FoldWith<V>>::fold_with(extends, visitor) };
-                let body = { <TsInterfaceBody as FoldWith<V>>::fold_with(body, visitor) };
-                TsInterfaceDecl {
-                    span,
-                    id,
-                    declare,
-                    type_params,
-                    extends,
-                    body,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsIntersectionType {
-    #[doc = "Calls [Fold`::fold_ts_intersection_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_intersection_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsIntersectionType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_intersection_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_intersection_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsIntersectionType { span, types } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let types = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(types, visitor) };
-                TsIntersectionType { span, types }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
+                        self::fields::TsIntersectionTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
+                        self::fields::TsIntersectionTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsKeywordType {
-    #[doc = "Calls [Fold`::fold_ts_keyword_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_keyword_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsKeywordType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_keyword_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_keyword_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsKeywordType { span, kind } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let kind = { <TsKeywordTypeKind as FoldWith<V>>::fold_with(kind, visitor) };
-                TsKeywordType { span, kind }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
+                        self::fields::TsKeywordTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
+                        self::fields::TsKeywordTypeField::Kind,
+                    ));
+                    <TsKeywordTypeKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsKeywordTypeKind {
-    #[doc = "Calls [Fold`::fold_ts_keyword_type_kind`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_keyword_type_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsKeywordTypeKind {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_keyword_type_kind`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_keyword_type_kind(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            TsKeywordTypeKind::TsAnyKeyword => TsKeywordTypeKind::TsAnyKeyword,
-            TsKeywordTypeKind::TsUnknownKeyword => TsKeywordTypeKind::TsUnknownKeyword,
-            TsKeywordTypeKind::TsNumberKeyword => TsKeywordTypeKind::TsNumberKeyword,
-            TsKeywordTypeKind::TsObjectKeyword => TsKeywordTypeKind::TsObjectKeyword,
-            TsKeywordTypeKind::TsBooleanKeyword => TsKeywordTypeKind::TsBooleanKeyword,
-            TsKeywordTypeKind::TsBigIntKeyword => TsKeywordTypeKind::TsBigIntKeyword,
-            TsKeywordTypeKind::TsStringKeyword => TsKeywordTypeKind::TsStringKeyword,
-            TsKeywordTypeKind::TsSymbolKeyword => TsKeywordTypeKind::TsSymbolKeyword,
-            TsKeywordTypeKind::TsVoidKeyword => TsKeywordTypeKind::TsVoidKeyword,
-            TsKeywordTypeKind::TsUndefinedKeyword => TsKeywordTypeKind::TsUndefinedKeyword,
-            TsKeywordTypeKind::TsNullKeyword => TsKeywordTypeKind::TsNullKeyword,
-            TsKeywordTypeKind::TsNeverKeyword => TsKeywordTypeKind::TsNeverKeyword,
-            TsKeywordTypeKind::TsIntrinsicKeyword => TsKeywordTypeKind::TsIntrinsicKeyword,
+            TsKeywordTypeKind::TsAnyKeyword => {}
+            TsKeywordTypeKind::TsUnknownKeyword => {}
+            TsKeywordTypeKind::TsNumberKeyword => {}
+            TsKeywordTypeKind::TsObjectKeyword => {}
+            TsKeywordTypeKind::TsBooleanKeyword => {}
+            TsKeywordTypeKind::TsBigIntKeyword => {}
+            TsKeywordTypeKind::TsStringKeyword => {}
+            TsKeywordTypeKind::TsSymbolKeyword => {}
+            TsKeywordTypeKind::TsVoidKeyword => {}
+            TsKeywordTypeKind::TsUndefinedKeyword => {}
+            TsKeywordTypeKind::TsNullKeyword => {}
+            TsKeywordTypeKind::TsNeverKeyword => {}
+            TsKeywordTypeKind::TsIntrinsicKeyword => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsLit {
-    #[doc = "Calls [Fold`::fold_ts_lit`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsLit {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_lit`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_lit(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsLit::Number { 0: _field_0 } => {
-                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsLit::Number { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Number));
+                <Number as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsLit::Str { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Str));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::Bool { 0: _field_0 } => {
-                let _field_0 = <Bool as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsLit::Bool { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Bool));
+                <Bool as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::BigInt { 0: _field_0 } => {
-                let _field_0 = <BigInt as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsLit::BigInt { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::BigInt));
+                <BigInt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsLit::Tpl { 0: _field_0 } => {
-                let _field_0 = <TsTplLitType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsLit::Tpl { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Tpl));
+                <TsTplLitType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsLitType {
-    #[doc = "Calls [Fold`::fold_ts_lit_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_lit_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsLitType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_lit_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_lit_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsLitType { span, lit } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let lit = { <TsLit as FoldWith<V>>::fold_with(lit, visitor) };
-                TsLitType { span, lit }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Lit));
+                    <TsLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        lit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsMappedType {
-    #[doc = "Calls [Fold`::fold_ts_mapped_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_mapped_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsMappedType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_mapped_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_mapped_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsMappedType {
                 span,
@@ -107819,35 +87836,79 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsMappedType {
                 optional,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let readonly =
-                    { <Option<TruePlusMinus> as FoldWith<V>>::fold_with(readonly, visitor) };
-                let type_param = { <TsTypeParam as FoldWith<V>>::fold_with(type_param, visitor) };
-                let name_type =
-                    { <Option<Box<TsType>> as FoldWith<V>>::fold_with(name_type, visitor) };
-                let optional =
-                    { <Option<TruePlusMinus> as FoldWith<V>>::fold_with(optional, visitor) };
-                let type_ann =
-                    { <Option<Box<TsType>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsMappedType {
-                    span,
-                    readonly,
-                    type_param,
-                    name_type,
-                    optional,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::Readonly,
+                    ));
+                    <Option<TruePlusMinus> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        readonly,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::TypeParam,
+                    ));
+                    <TsTypeParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::NameType,
+                    ));
+                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::Optional,
+                    ));
+                    <Option<TruePlusMinus> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        optional,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::TypeAnn,
+                    ));
+                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsMethodSignature {
-    #[doc = "Calls [Fold`::fold_ts_method_signature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_method_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsMethodSignature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_method_signature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_method_signature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsMethodSignature {
                 span,
@@ -107858,50 +87919,100 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsMethodSignature {
                 type_ann,
                 type_params,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
-                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::Key,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
                 };
-                TsMethodSignature {
-                    span,
-                    key,
-                    computed,
-                    optional,
-                    params,
-                    type_ann,
-                    type_params,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsModuleBlock {
-    #[doc = "Calls [Fold`::fold_ts_module_block`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_module_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleBlock {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_block`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_block(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsModuleBlock { span, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let body = { <Vec<ModuleItem> as FoldWith<V>>::fold_with(body, visitor) };
-                TsModuleBlock { span, body }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
+                        self::fields::TsModuleBlockField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
+                        self::fields::TsModuleBlockField::Body(usize::MAX),
+                    ));
+                    <Vec<ModuleItem> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsModuleDecl {
-    #[doc = "Calls [Fold`::fold_ts_module_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_module_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsModuleDecl {
                 span,
@@ -107910,84 +88021,148 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsModuleDecl {
                 id,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <TsModuleName as FoldWith<V>>::fold_with(id, visitor) };
-                let body = { <Option<TsNamespaceBody> as FoldWith<V>>::fold_with(body, visitor) };
-                TsModuleDecl {
-                    span,
-                    declare,
-                    global,
-                    id,
-                    body,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
+                        self::fields::TsModuleDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
+                        self::fields::TsModuleDeclField::Id,
+                    ));
+                    <TsModuleName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
+                        self::fields::TsModuleDeclField::Body,
+                    ));
+                    <Option<TsNamespaceBody> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsModuleName {
-    #[doc = "Calls [Fold`::fold_ts_module_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_module_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsModuleName::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsModuleName::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
+                    self::fields::TsModuleNameField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsModuleName::Str { 0: _field_0 } => {
-                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsModuleName::Str { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
+                    self::fields::TsModuleNameField::Str,
+                ));
+                <Str as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsModuleRef {
-    #[doc = "Calls [Fold`::fold_ts_module_ref`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_module_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsModuleRef {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_module_ref`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_module_ref(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsModuleRef::TsEntityName { 0: _field_0 } => {
-                let _field_0 = <TsEntityName as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsModuleRef::TsEntityName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
+                    self::fields::TsModuleRefField::TsEntityName,
+                ));
+                <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsModuleRef::TsExternalModuleRef { 0: _field_0 } => {
-                let _field_0 = <TsExternalModuleRef as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsModuleRef::TsExternalModuleRef { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
+                    self::fields::TsModuleRefField::TsExternalModuleRef,
+                ));
+                <TsExternalModuleRef as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsNamespaceBody {
-    #[doc = "Calls [Fold`::fold_ts_namespace_body`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_namespace_body(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNamespaceBody {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_namespace_body`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_body(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsNamespaceBody::TsModuleBlock { 0: _field_0 } => {
-                let _field_0 = <TsModuleBlock as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsNamespaceBody::TsModuleBlock { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
+                    self::fields::TsNamespaceBodyField::TsModuleBlock,
+                ));
+                <TsModuleBlock as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsNamespaceBody::TsNamespaceDecl { 0: _field_0 } => {
-                let _field_0 = <TsNamespaceDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsNamespaceBody::TsNamespaceDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
+                    self::fields::TsNamespaceBodyField::TsNamespaceDecl,
+                ));
+                <TsNamespaceDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsNamespaceDecl {
-    #[doc = "Calls [Fold`::fold_ts_namespace_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_namespace_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNamespaceDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_namespace_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsNamespaceDecl {
                 span,
@@ -107996,75 +88171,156 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsNamespaceDecl {
                 id,
                 body,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
-                let body = { <Box<TsNamespaceBody> as FoldWith<V>>::fold_with(body, visitor) };
-                TsNamespaceDecl {
-                    span,
-                    declare,
-                    global,
-                    id,
-                    body,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
+                        self::fields::TsNamespaceDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
+                        self::fields::TsNamespaceDeclField::Id,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
+                        self::fields::TsNamespaceDeclField::Body,
+                    ));
+                    <Box<TsNamespaceBody> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsNamespaceExportDecl {
-    #[doc = "Calls [Fold`::fold_ts_namespace_export_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_namespace_export_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNamespaceExportDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_namespace_export_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_namespace_export_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsNamespaceExportDecl { span, id } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
-                TsNamespaceExportDecl { span, id }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
+                            self::fields::TsNamespaceExportDeclField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
+                            self::fields::TsNamespaceExportDeclField::Id,
+                        ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsNonNullExpr {
-    #[doc = "Calls [Fold`::fold_ts_non_null_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_non_null_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsNonNullExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_non_null_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_non_null_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsNonNullExpr { span, expr } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                TsNonNullExpr { span, expr }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
+                        self::fields::TsNonNullExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
+                        self::fields::TsNonNullExprField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsOptionalType {
-    #[doc = "Calls [Fold`::fold_ts_optional_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_optional_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsOptionalType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_optional_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_optional_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsOptionalType { span, type_ann } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsOptionalType { span, type_ann }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
+                        self::fields::TsOptionalTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
+                        self::fields::TsOptionalTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsParamProp {
-    #[doc = "Calls [Fold`::fold_ts_param_prop`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_param_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsParamProp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_param_prop`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_param_prop(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsParamProp {
                 span,
@@ -108074,66 +88330,127 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsParamProp {
                 readonly,
                 param,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let decorators =
-                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
-                let accessibility =
-                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
-                let param = { <TsParamPropParam as FoldWith<V>>::fold_with(param, visitor) };
-                TsParamProp {
-                    span,
-                    decorators,
-                    accessibility,
-                    is_override,
-                    readonly,
-                    param,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Param,
+                    ));
+                    <TsParamPropParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsParamPropParam {
-    #[doc = "Calls [Fold`::fold_ts_param_prop_param`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_param_prop_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsParamPropParam {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_param_prop_param`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_param_prop_param(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsParamPropParam::Ident { 0: _field_0 } => {
-                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsParamPropParam::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
+                    self::fields::TsParamPropParamField::Ident,
+                ));
+                <BindingIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsParamPropParam::Assign { 0: _field_0 } => {
-                let _field_0 = <AssignPat as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsParamPropParam::Assign { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
+                    self::fields::TsParamPropParamField::Assign,
+                ));
+                <AssignPat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsParenthesizedType {
-    #[doc = "Calls [Fold`::fold_ts_parenthesized_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_parenthesized_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsParenthesizedType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_parenthesized_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_parenthesized_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsParenthesizedType { span, type_ann } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsParenthesizedType { span, type_ann }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
+                        self::fields::TsParenthesizedTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
+                        self::fields::TsParenthesizedTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsPropertySignature {
-    #[doc = "Calls [Fold`::fold_ts_property_signature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_property_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsPropertySignature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_property_signature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_property_signature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsPropertySignature {
                 span,
@@ -108143,87 +88460,178 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsPropertySignature {
                 optional,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsPropertySignature {
-                    span,
-                    readonly,
-                    key,
-                    computed,
-                    optional,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
+                        self::fields::TsPropertySignatureField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
+                        self::fields::TsPropertySignatureField::Key,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
+                        self::fields::TsPropertySignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsQualifiedName {
-    #[doc = "Calls [Fold`::fold_ts_qualified_name`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_qualified_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsQualifiedName {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_qualified_name`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_qualified_name(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsQualifiedName { span, left, right } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let left = { <TsEntityName as FoldWith<V>>::fold_with(left, visitor) };
-                let right = { <IdentName as FoldWith<V>>::fold_with(right, visitor) };
-                TsQualifiedName { span, left, right }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
+                        self::fields::TsQualifiedNameField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
+                        self::fields::TsQualifiedNameField::Left,
+                    ));
+                    <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
+                        self::fields::TsQualifiedNameField::Right,
+                    ));
+                    <IdentName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsRestType {
-    #[doc = "Calls [Fold`::fold_ts_rest_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_rest_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsRestType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_rest_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_rest_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsRestType { span, type_ann } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsRestType { span, type_ann }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
+                        self::fields::TsRestTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
+                        self::fields::TsRestTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsSatisfiesExpr {
-    #[doc = "Calls [Fold`::fold_ts_satisfies_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_satisfies_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsSatisfiesExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_satisfies_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_satisfies_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsSatisfiesExpr {
                 span,
                 expr,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsSatisfiesExpr {
-                    span,
-                    expr,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
+                        self::fields::TsSatisfiesExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
+                        self::fields::TsSatisfiesExprField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
+                        self::fields::TsSatisfiesExprField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsSetterSignature {
-    #[doc = "Calls [Fold`::fold_ts_setter_signature`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_setter_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsSetterSignature {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_setter_signature`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_setter_signature(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsSetterSignature {
                 span,
@@ -108231,211 +88639,444 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsSetterSignature {
                 computed,
                 param,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
-                let param = { <TsFnParam as FoldWith<V>>::fold_with(param, visitor) };
-                TsSetterSignature {
-                    span,
-                    key,
-                    computed,
-                    param,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
+                        self::fields::TsSetterSignatureField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
+                        self::fields::TsSetterSignatureField::Key,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
+                        self::fields::TsSetterSignatureField::Param,
+                    ));
+                    <TsFnParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsThisType {
-    #[doc = "Calls [Fold`::fold_ts_this_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_this_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsThisType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_this_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_this_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsThisType { span } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                TsThisType { span }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisType(
+                        self::fields::TsThisTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsThisTypeOrIdent {
-    #[doc = "Calls [Fold`::fold_ts_this_type_or_ident`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_this_type_or_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsThisTypeOrIdent {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_this_type_or_ident`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_this_type_or_ident(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsThisTypeOrIdent::TsThisType { 0: _field_0 } => {
-                let _field_0 = <TsThisType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsThisTypeOrIdent::TsThisType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
+                    self::fields::TsThisTypeOrIdentField::TsThisType,
+                ));
+                <TsThisType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsThisTypeOrIdent::Ident { 0: _field_0 } => {
-                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsThisTypeOrIdent::Ident { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
+                    self::fields::TsThisTypeOrIdentField::Ident,
+                ));
+                <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTplLitType {
-    #[doc = "Calls [Fold`::fold_ts_tpl_lit_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_tpl_lit_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTplLitType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tpl_lit_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tpl_lit_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTplLitType {
                 span,
                 types,
                 quasis,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let types = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(types, visitor) };
-                let quasis = { <Vec<TplElement> as FoldWith<V>>::fold_with(quasis, visitor) };
-                TsTplLitType {
-                    span,
-                    types,
-                    quasis,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
+                        self::fields::TsTplLitTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
+                        self::fields::TsTplLitTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
+                        self::fields::TsTplLitTypeField::Quasis(usize::MAX),
+                    ));
+                    <Vec<TplElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        quasis,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTupleElement {
-    #[doc = "Calls [Fold`::fold_ts_tuple_element`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_tuple_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTupleElement {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tuple_element`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_element(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTupleElement { span, label, ty } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let label = { <Option<Pat> as FoldWith<V>>::fold_with(label, visitor) };
-                let ty = { <Box<TsType> as FoldWith<V>>::fold_with(ty, visitor) };
-                TsTupleElement { span, label, ty }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
+                        self::fields::TsTupleElementField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
+                        self::fields::TsTupleElementField::Label,
+                    ));
+                    <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
+                        self::fields::TsTupleElementField::Ty,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ty,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTupleType {
-    #[doc = "Calls [Fold`::fold_ts_tuple_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_tuple_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTupleType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tuple_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTupleType { span, elem_types } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let elem_types =
-                    { <Vec<TsTupleElement> as FoldWith<V>>::fold_with(elem_types, visitor) };
-                TsTupleType { span, elem_types }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
+                        self::fields::TsTupleTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
+                        self::fields::TsTupleTypeField::ElemTypes(usize::MAX),
+                    ));
+                    <Vec<TsTupleElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        elem_types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsType {
-    #[doc = "Calls [Fold`::fold_ts_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsType::TsKeywordType { 0: _field_0 } => {
-                let _field_0 = <TsKeywordType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsKeywordType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsKeywordType,
+                ));
+                <TsKeywordType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsThisType { 0: _field_0 } => {
-                let _field_0 = <TsThisType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsThisType { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsThisType));
+                <TsThisType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsFnOrConstructorType { 0: _field_0 } => {
-                let _field_0 = <TsFnOrConstructorType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsFnOrConstructorType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsFnOrConstructorType,
+                ));
+                <TsFnOrConstructorType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeRef { 0: _field_0 } => {
-                let _field_0 = <TsTypeRef as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsTypeRef { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeRef));
+                <TsTypeRef as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeQuery { 0: _field_0 } => {
-                let _field_0 = <TsTypeQuery as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsTypeQuery { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTypeQuery,
+                ));
+                <TsTypeQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeLit { 0: _field_0 } => {
-                let _field_0 = <TsTypeLit as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsTypeLit { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeLit));
+                <TsTypeLit as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsArrayType { 0: _field_0 } => {
-                let _field_0 = <TsArrayType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsArrayType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsArrayType,
+                ));
+                <TsArrayType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTupleType { 0: _field_0 } => {
-                let _field_0 = <TsTupleType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsTupleType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTupleType,
+                ));
+                <TsTupleType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsOptionalType { 0: _field_0 } => {
-                let _field_0 = <TsOptionalType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsOptionalType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsOptionalType,
+                ));
+                <TsOptionalType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsRestType { 0: _field_0 } => {
-                let _field_0 = <TsRestType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsRestType { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsRestType));
+                <TsRestType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsUnionOrIntersectionType { 0: _field_0 } => {
-                let _field_0 =
-                    <TsUnionOrIntersectionType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsUnionOrIntersectionType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsUnionOrIntersectionType,
+                ));
+                <TsUnionOrIntersectionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsConditionalType { 0: _field_0 } => {
-                let _field_0 = <TsConditionalType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsConditionalType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsConditionalType,
+                ));
+                <TsConditionalType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsInferType { 0: _field_0 } => {
-                let _field_0 = <TsInferType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsInferType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsInferType,
+                ));
+                <TsInferType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsParenthesizedType { 0: _field_0 } => {
-                let _field_0 = <TsParenthesizedType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsParenthesizedType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsParenthesizedType,
+                ));
+                <TsParenthesizedType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypeOperator { 0: _field_0 } => {
-                let _field_0 = <TsTypeOperator as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsTypeOperator { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTypeOperator,
+                ));
+                <TsTypeOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsIndexedAccessType { 0: _field_0 } => {
-                let _field_0 = <TsIndexedAccessType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsIndexedAccessType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsIndexedAccessType,
+                ));
+                <TsIndexedAccessType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsMappedType { 0: _field_0 } => {
-                let _field_0 = <TsMappedType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsMappedType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsMappedType,
+                ));
+                <TsMappedType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsLitType { 0: _field_0 } => {
-                let _field_0 = <TsLitType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsLitType { 0: _field_0 }
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsLitType));
+                <TsLitType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsTypePredicate { 0: _field_0 } => {
-                let _field_0 = <TsTypePredicate as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsTypePredicate { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTypePredicate,
+                ));
+                <TsTypePredicate as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsType::TsImportType { 0: _field_0 } => {
-                let _field_0 = <TsImportType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsType::TsImportType { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsImportType,
+                ));
+                <TsImportType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeAliasDecl {
-    #[doc = "Calls [Fold`::fold_ts_type_alias_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_alias_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAliasDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_alias_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_alias_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeAliasDecl {
                 span,
@@ -108444,158 +89085,316 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsTypeAliasDecl {
                 type_params,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::Id,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamDecl > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsTypeAliasDecl {
-                    span,
-                    declare,
-                    id,
-                    type_params,
-                    type_ann,
-                }
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeAnn {
-    #[doc = "Calls [Fold`::fold_ts_type_ann`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_ann(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAnn {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_ann`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_ann(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeAnn { span, type_ann } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsTypeAnn { span, type_ann }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsTypeAnn(self::fields::TsTypeAnnField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAnn(
+                        self::fields::TsTypeAnnField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeAssertion {
-    #[doc = "Calls [Fold`::fold_ts_type_assertion`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_assertion(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeAssertion {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_assertion`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_assertion(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeAssertion {
                 span,
                 expr,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsTypeAssertion {
-                    span,
-                    expr,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
+                        self::fields::TsTypeAssertionField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
+                        self::fields::TsTypeAssertionField::Expr,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
+                        self::fields::TsTypeAssertionField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeElement {
-    #[doc = "Calls [Fold`::fold_ts_type_element`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeElement {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_element`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_element(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeElement::TsCallSignatureDecl { 0: _field_0 } => {
-                let _field_0 = <TsCallSignatureDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeElement::TsCallSignatureDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsCallSignatureDecl,
+                ));
+                <TsCallSignatureDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsConstructSignatureDecl { 0: _field_0 } => {
-                let _field_0 =
-                    <TsConstructSignatureDecl as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeElement::TsConstructSignatureDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsConstructSignatureDecl,
+                ));
+                <TsConstructSignatureDecl as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsPropertySignature { 0: _field_0 } => {
-                let _field_0 = <TsPropertySignature as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeElement::TsPropertySignature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsPropertySignature,
+                ));
+                <TsPropertySignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsGetterSignature { 0: _field_0 } => {
-                let _field_0 = <TsGetterSignature as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeElement::TsGetterSignature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsGetterSignature,
+                ));
+                <TsGetterSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsSetterSignature { 0: _field_0 } => {
-                let _field_0 = <TsSetterSignature as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeElement::TsSetterSignature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsSetterSignature,
+                ));
+                <TsSetterSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsMethodSignature { 0: _field_0 } => {
-                let _field_0 = <TsMethodSignature as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeElement::TsMethodSignature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsMethodSignature,
+                ));
+                <TsMethodSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeElement::TsIndexSignature { 0: _field_0 } => {
-                let _field_0 = <TsIndexSignature as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeElement::TsIndexSignature { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsIndexSignature,
+                ));
+                <TsIndexSignature as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeLit {
-    #[doc = "Calls [Fold`::fold_ts_type_lit`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeLit {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_lit`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_lit(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeLit { span, members } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let members = { <Vec<TsTypeElement> as FoldWith<V>>::fold_with(members, visitor) };
-                TsTypeLit { span, members }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsTypeLit(self::fields::TsTypeLitField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeLit(
+                        self::fields::TsTypeLitField::Members(usize::MAX),
+                    ));
+                    <Vec<TsTypeElement> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        members,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeOperator {
-    #[doc = "Calls [Fold`::fold_ts_type_operator`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeOperator {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_operator`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_operator(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeOperator { span, op, type_ann } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let op = { <TsTypeOperatorOp as FoldWith<V>>::fold_with(op, visitor) };
-                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsTypeOperator { span, op, type_ann }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
+                        self::fields::TsTypeOperatorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
+                        self::fields::TsTypeOperatorField::Op,
+                    ));
+                    <TsTypeOperatorOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
+                        self::fields::TsTypeOperatorField::TypeAnn,
+                    ));
+                    <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeOperatorOp {
-    #[doc = "Calls [Fold`::fold_ts_type_operator_op`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_operator_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeOperatorOp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_operator_op`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_operator_op(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            TsTypeOperatorOp::KeyOf => TsTypeOperatorOp::KeyOf,
-            TsTypeOperatorOp::Unique => TsTypeOperatorOp::Unique,
-            TsTypeOperatorOp::ReadOnly => TsTypeOperatorOp::ReadOnly,
+            TsTypeOperatorOp::KeyOf => {}
+            TsTypeOperatorOp::Unique => {}
+            TsTypeOperatorOp::ReadOnly => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeParam {
-    #[doc = "Calls [Fold`::fold_ts_type_param`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeParam {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_param`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeParam {
                 span,
@@ -108606,63 +89405,131 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsTypeParam {
                 constraint,
                 default,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
-                let constraint =
-                    { <Option<Box<TsType>> as FoldWith<V>>::fold_with(constraint, visitor) };
-                let default = { <Option<Box<TsType>> as FoldWith<V>>::fold_with(default, visitor) };
-                TsTypeParam {
-                    span,
-                    name,
-                    is_in,
-                    is_out,
-                    is_const,
-                    constraint,
-                    default,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Name,
+                    ));
+                    <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Constraint,
+                    ));
+                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        constraint,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Default,
+                    ));
+                    <Option<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        default,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeParamDecl {
-    #[doc = "Calls [Fold`::fold_ts_type_param_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_param_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeParamDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_param_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeParamDecl { span, params } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let params = { <Vec<TsTypeParam> as FoldWith<V>>::fold_with(params, visitor) };
-                TsTypeParamDecl { span, params }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
+                        self::fields::TsTypeParamDeclField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
+                        self::fields::TsTypeParamDeclField::Params(usize::MAX),
+                    ));
+                    <Vec<TsTypeParam> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeParamInstantiation {
-    #[doc = "Calls [Fold`::fold_ts_type_param_instantiation`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_param_instantiation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeParamInstantiation {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_param_instantiation`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_param_instantiation(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeParamInstantiation { span, params } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let params = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(params, visitor) };
-                TsTypeParamInstantiation { span, params }
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
+                            self::fields::TsTypeParamInstantiationField::Span,
+                        ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
+                            self::fields::TsTypeParamInstantiationField::Params(usize::MAX),
+                        ));
+                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypePredicate {
-    #[doc = "Calls [Fold`::fold_ts_type_predicate`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_predicate(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypePredicate {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_predicate`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_predicate(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypePredicate {
                 span,
@@ -108670,176 +89537,303 @@ impl<V: ?Sized + Fold> FoldWith<V> for TsTypePredicate {
                 param_name,
                 type_ann,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let param_name =
-                    { <TsThisTypeOrIdent as FoldWith<V>>::fold_with(param_name, visitor) };
-                let type_ann =
-                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
-                TsTypePredicate {
-                    span,
-                    asserts,
-                    param_name,
-                    type_ann,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
+                        self::fields::TsTypePredicateField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
+                        self::fields::TsTypePredicateField::ParamName,
+                    ));
+                    <TsThisTypeOrIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        param_name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
+                        self::fields::TsTypePredicateField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeQuery {
-    #[doc = "Calls [Fold`::fold_ts_type_query`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeQuery {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_query`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_query(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeQuery {
                 span,
                 expr_name,
                 type_args,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let expr_name = { <TsTypeQueryExpr as FoldWith<V>>::fold_with(expr_name, visitor) };
-                let type_args = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_args, visitor,
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
+                        self::fields::TsTypeQueryField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
-                TsTypeQuery {
-                    span,
-                    expr_name,
-                    type_args,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
+                        self::fields::TsTypeQueryField::ExprName,
+                    ));
+                    <TsTypeQueryExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        expr_name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
+                        self::fields::TsTypeQueryField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeQueryExpr {
-    #[doc = "Calls [Fold`::fold_ts_type_query_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_query_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeQueryExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_query_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_query_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeQueryExpr::TsEntityName { 0: _field_0 } => {
-                let _field_0 = <TsEntityName as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeQueryExpr::TsEntityName { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
+                    self::fields::TsTypeQueryExprField::TsEntityName,
+                ));
+                <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsTypeQueryExpr::Import { 0: _field_0 } => {
-                let _field_0 = <TsImportType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsTypeQueryExpr::Import { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
+                    self::fields::TsTypeQueryExprField::Import,
+                ));
+                <TsImportType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsTypeRef {
-    #[doc = "Calls [Fold`::fold_ts_type_ref`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsTypeRef {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_ref`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_ref(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsTypeRef {
                 span,
                 type_name,
                 type_params,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let type_name = { <TsEntityName as FoldWith<V>>::fold_with(type_name, visitor) };
-                let type_params = {
-                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
-                        type_params,
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsTypeRef(self::fields::TsTypeRefField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                TsTypeRef {
-                    span,
-                    type_name,
-                    type_params,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
+                        self::fields::TsTypeRefField::TypeName,
+                    ));
+                    <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        type_name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
+                        self::fields::TsTypeRefField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as VisitMutWithAstPath < V > > :: visit_mut_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsUnionOrIntersectionType {
-    #[doc = "Calls [Fold`::fold_ts_union_or_intersection_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_union_or_intersection_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsUnionOrIntersectionType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_union_or_intersection_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_union_or_intersection_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsUnionOrIntersectionType::TsUnionType { 0: _field_0 } => {
-                let _field_0 = <TsUnionType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsUnionOrIntersectionType::TsUnionType { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
+                        self::fields::TsUnionOrIntersectionTypeField::TsUnionType,
+                    ));
+                <TsUnionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 } => {
-                let _field_0 = <TsIntersectionType as FoldWith<V>>::fold_with(_field_0, visitor);
-                TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 }
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
+                        self::fields::TsUnionOrIntersectionTypeField::TsIntersectionType,
+                    ));
+                <TsIntersectionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for TsUnionType {
-    #[doc = "Calls [Fold`::fold_ts_union_type`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_union_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TsUnionType {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_union_type`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_union_type(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             TsUnionType { span, types } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let types = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(types, visitor) };
-                TsUnionType { span, types }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
+                        self::fields::TsUnionTypeField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
+                        self::fields::TsUnionTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UnaryExpr {
-    #[doc = "Calls [Fold`::fold_unary_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_unary_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnaryExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_unary_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unary_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UnaryExpr { span, op, arg } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let op = { <UnaryOp as FoldWith<V>>::fold_with(op, visitor) };
-                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
-                UnaryExpr { span, op, arg }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Op));
+                    <UnaryOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Arg));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UnaryOp {
-    #[doc = "Calls [Fold`::fold_unary_op`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_unary_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UnaryOp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_unary_op`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_unary_op(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            UnaryOp::Minus => UnaryOp::Minus,
-            UnaryOp::Plus => UnaryOp::Plus,
-            UnaryOp::Bang => UnaryOp::Bang,
-            UnaryOp::Tilde => UnaryOp::Tilde,
-            UnaryOp::TypeOf => UnaryOp::TypeOf,
-            UnaryOp::Void => UnaryOp::Void,
-            UnaryOp::Delete => UnaryOp::Delete,
+            UnaryOp::Minus => {}
+            UnaryOp::Plus => {}
+            UnaryOp::Bang => {}
+            UnaryOp::Tilde => {}
+            UnaryOp::TypeOf => {}
+            UnaryOp::Void => {}
+            UnaryOp::Delete => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UpdateExpr {
-    #[doc = "Calls [Fold`::fold_update_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_update_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UpdateExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_update_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_update_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UpdateExpr {
                 span,
@@ -108847,63 +89841,101 @@ impl<V: ?Sized + Fold> FoldWith<V> for UpdateExpr {
                 prefix,
                 arg,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let op = { <UpdateOp as FoldWith<V>>::fold_with(op, visitor) };
-                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
-                UpdateExpr {
-                    span,
-                    op,
-                    prefix,
-                    arg,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
+                        self::fields::UpdateExprField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UpdateExpr(self::fields::UpdateExprField::Op));
+                    <UpdateOp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
+                        self::fields::UpdateExprField::Arg,
+                    ));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UpdateOp {
-    #[doc = "Calls [Fold`::fold_update_op`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_update_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UpdateOp {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_update_op`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_update_op(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            UpdateOp::PlusPlus => UpdateOp::PlusPlus,
-            UpdateOp::MinusMinus => UpdateOp::MinusMinus,
+            UpdateOp::PlusPlus => {}
+            UpdateOp::MinusMinus => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for UsingDecl {
-    #[doc = "Calls [Fold`::fold_using_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_using_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for UsingDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_using_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_using_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             UsingDecl {
                 span,
                 is_await,
                 decls,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let decls = { <Vec<VarDeclarator> as FoldWith<V>>::fold_with(decls, visitor) };
-                UsingDecl {
-                    span,
-                    is_await,
-                    decls,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UsingDecl(self::fields::UsingDeclField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UsingDecl(
+                        self::fields::UsingDeclField::Decls(usize::MAX),
+                    ));
+                    <Vec<VarDeclarator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decls,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for VarDecl {
-    #[doc = "Calls [Fold`::fold_var_decl`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_var_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDecl {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_decl`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_decl(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             VarDecl {
                 span,
@@ -108912,61 +89944,105 @@ impl<V: ?Sized + Fold> FoldWith<V> for VarDecl {
                 declare,
                 decls,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
-                let kind = { <VarDeclKind as FoldWith<V>>::fold_with(kind, visitor) };
-                let decls = { <Vec<VarDeclarator> as FoldWith<V>>::fold_with(decls, visitor) };
-                VarDecl {
-                    span,
-                    ctxt,
-                    kind,
-                    declare,
-                    decls,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Ctxt));
+                    <swc_common::SyntaxContext as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Kind));
+                    <VarDeclKind as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDecl(
+                        self::fields::VarDeclField::Decls(usize::MAX),
+                    ));
+                    <Vec<VarDeclarator> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        decls,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for VarDeclKind {
-    #[doc = "Calls [Fold`::fold_var_decl_kind`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_var_decl_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclKind {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_decl_kind`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_decl_kind(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
-            VarDeclKind::Var => VarDeclKind::Var,
-            VarDeclKind::Let => VarDeclKind::Let,
-            VarDeclKind::Const => VarDeclKind::Const,
+            VarDeclKind::Var => {}
+            VarDeclKind::Let => {}
+            VarDeclKind::Const => {}
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for VarDeclOrExpr {
-    #[doc = "Calls [Fold`::fold_var_decl_or_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_var_decl_or_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclOrExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_decl_or_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_decl_or_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             VarDeclOrExpr::VarDecl { 0: _field_0 } => {
-                let _field_0 = <Box<VarDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
-                VarDeclOrExpr::VarDecl { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
+                    self::fields::VarDeclOrExprField::VarDecl,
+                ));
+                <Box<VarDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
             VarDeclOrExpr::Expr { 0: _field_0 } => {
-                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
-                VarDeclOrExpr::Expr { 0: _field_0 }
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
+                    self::fields::VarDeclOrExprField::Expr,
+                ));
+                <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for VarDeclarator {
-    #[doc = "Calls [Fold`::fold_var_declarator`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_var_declarator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for VarDeclarator {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_declarator`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_declarator(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             VarDeclarator {
                 span,
@@ -108974,8852 +90050,6786 @@ impl<V: ?Sized + Fold> FoldWith<V> for VarDeclarator {
                 init,
                 definite,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let name = { <Pat as FoldWith<V>>::fold_with(name, visitor) };
-                let init = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(init, visitor) };
-                VarDeclarator {
-                    span,
-                    name,
-                    init,
-                    definite,
-                }
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
+                        self::fields::VarDeclaratorField::Span,
+                    ));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
+                        self::fields::VarDeclaratorField::Name,
+                    ));
+                    <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
+                        self::fields::VarDeclaratorField::Init,
+                    ));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
-}
-impl<V: ?Sized + Fold> FoldWith<V> for WhileStmt {
-    #[doc = "Calls [Fold`::fold_while_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_while_stmt(visitor, self)
+}
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WhileStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_while_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_while_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             WhileStmt { span, test, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
-                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                WhileStmt { span, test, body }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Test));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Body));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for WithStmt {
-    #[doc = "Calls [Fold`::fold_with_stmt`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_with_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WithStmt {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_with_stmt`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_with_stmt(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             WithStmt { span, obj, body } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let obj = { <Box<Expr> as FoldWith<V>>::fold_with(obj, visitor) };
-                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
-                WithStmt { span, obj, body }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Obj));
+                    <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Body));
+                    <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for YieldExpr {
-    #[doc = "Calls [Fold`::fold_yield_expr`] with `self`."]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_yield_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for YieldExpr {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_yield_expr`] with `self`."]
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_yield_expr(visitor, self, __ast_path)
     }
 
-    fn fold_children_with(self, visitor: &mut V) -> Self {
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             YieldExpr {
                 span,
                 arg,
                 delegate,
             } => {
-                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
-                let arg = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(arg, visitor) };
-                YieldExpr {
-                    span,
-                    arg,
-                    delegate,
-                }
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Span));
+                    <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
+                {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Arg));
+                    <Option<Box<Expr>> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
+                };
             }
         }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_atom(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        {}
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for BigIntValue {
-    #[doc = "Calls [Fold`::fold_big_int_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BigIntValue {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_big_int_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_big_int_value(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_big_int_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        {}
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ClassMember> {
-    #[doc = "Calls [Fold`::fold_class_members`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ClassMember> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_class_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_class_members(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_class_members(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ClassMember as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ClassMember as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Decorator> {
-    #[doc = "Calls [Fold`::fold_decorators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Decorator> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_decorators`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_decorators(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_decorators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Decorator as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Decorator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExportSpecifier> {
-    #[doc = "Calls [Fold`::fold_export_specifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ExportSpecifier> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_export_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_export_specifiers(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_export_specifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ExportSpecifier as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ExportSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExprOrSpread> {
-    #[doc = "Calls [Fold`::fold_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ExprOrSpread> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_expr_or_spreads(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ExprOrSpread as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ExprOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<Expr>> {
-    #[doc = "Calls [Fold`::fold_exprs`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Box<Expr>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_exprs`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_exprs(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_exprs(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Box<Expr> as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportSpecifier> {
-    #[doc = "Calls [Fold`::fold_import_specifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ImportSpecifier> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_specifiers(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_specifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ImportSpecifier as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ImportSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportWithItem> {
-    #[doc = "Calls [Fold`::fold_import_with_items`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ImportWithItem> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_import_with_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_import_with_items(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_import_with_items(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ImportWithItem as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ImportWithItem as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<JSXAttrOrSpread> {
-    #[doc = "Calls [Fold`::fold_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<JSXAttrOrSpread> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_attr_or_spreads(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_attr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <JSXAttrOrSpread as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <JSXAttrOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<JSXElementChild> {
-    #[doc = "Calls [Fold`::fold_jsx_element_childs`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<JSXElementChild> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_jsx_element_childs`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_jsx_element_childs(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_jsx_element_childs(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <JSXElementChild as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <JSXElementChild as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ModuleItem> {
-    #[doc = "Calls [Fold`::fold_module_items`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ModuleItem> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_module_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_module_items(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_module_items(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ModuleItem as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ModuleItem as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ObjectPatProp> {
-    #[doc = "Calls [Fold`::fold_object_pat_props`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ObjectPatProp> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_object_pat_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_object_pat_props(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_object_pat_props(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ObjectPatProp as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ObjectPatProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Accessibility> {
-    #[doc = "Calls [Fold`::fold_opt_accessibility`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Accessibility> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_accessibility`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_accessibility(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_accessibility(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Accessibility as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Accessibility as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [Fold`::fold_opt_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_atom(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <swc_atoms::Atom as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<BlockStmt> {
-    #[doc = "Calls [Fold`::fold_opt_block_stmt`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<BlockStmt> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_block_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_block_stmt(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_block_stmt(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <BlockStmt as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <BlockStmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<CatchClause> {
-    #[doc = "Calls [Fold`::fold_opt_catch_clause`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<CatchClause> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_catch_clause`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_catch_clause(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_catch_clause(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <CatchClause as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <CatchClause as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Expr>> {
-    #[doc = "Calls [Fold`::fold_opt_expr`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Expr>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_expr(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<Expr> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<ExprOrSpread> {
-    #[doc = "Calls [Fold`::fold_opt_expr_or_spread`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ExprOrSpread> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_expr_or_spread`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_expr_or_spread(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spread(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <ExprOrSpread as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <ExprOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<ExprOrSpread>> {
-    #[doc = "Calls [Fold`::fold_opt_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<ExprOrSpread>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_expr_or_spreads(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Vec<ExprOrSpread> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Vec<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Ident> {
-    #[doc = "Calls [Fold`::fold_opt_ident`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Ident> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ident(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ident(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Ident as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<JSXAttrValue> {
-    #[doc = "Calls [Fold`::fold_opt_jsx_attr_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<JSXAttrValue> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_jsx_attr_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_jsx_attr_value(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_jsx_attr_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <JSXAttrValue as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <JSXAttrValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<JSXClosingElement> {
-    #[doc = "Calls [Fold`::fold_opt_jsx_closing_element`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<JSXClosingElement> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_jsx_closing_element`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_jsx_closing_element(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_jsx_closing_element(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <JSXClosingElement as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <JSXClosingElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<ModuleExportName> {
-    #[doc = "Calls [Fold`::fold_opt_module_export_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ModuleExportName> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_module_export_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_module_export_name(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_module_export_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <ModuleExportName as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <ModuleExportName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<ObjectLit>> {
-    #[doc = "Calls [Fold`::fold_opt_object_lit`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ObjectLit>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_object_lit`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_object_lit(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_object_lit(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<ObjectLit> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<ObjectLit> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Pat> {
-    #[doc = "Calls [Fold`::fold_opt_pat`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Pat> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_pat`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_pat(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_pat(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Pat as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(inner, visitor, __ast_path)
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<swc_common::Span> {
-    #[doc = "Calls [Fold`::fold_opt_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_common::Span> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_span(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <swc_common::Span as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <swc_common::Span as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Stmt>> {
-    #[doc = "Calls [Fold`::fold_opt_stmt`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Stmt>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_stmt(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_stmt(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<Stmt> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<Stmt> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Str>> {
-    #[doc = "Calls [Fold`::fold_opt_str`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Str>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_str`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_str(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_str(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<Str> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<Str> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<TruePlusMinus> {
-    #[doc = "Calls [Fold`::fold_opt_true_plus_minus`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TruePlusMinus> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_true_plus_minus`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_true_plus_minus(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_true_plus_minus(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <TruePlusMinus as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <TruePlusMinus as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<TsEntityName> {
-    #[doc = "Calls [Fold`::fold_opt_ts_entity_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TsEntityName> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_entity_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ts_entity_name(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_entity_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <TsEntityName as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <TsEntityName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<TsNamespaceBody> {
-    #[doc = "Calls [Fold`::fold_opt_ts_namespace_body`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TsNamespaceBody> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_namespace_body`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ts_namespace_body(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_namespace_body(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <TsNamespaceBody as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <TsNamespaceBody as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsType>> {
-    #[doc = "Calls [Fold`::fold_opt_ts_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsType>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ts_type(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<TsType> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsTypeAnn>> {
-    #[doc = "Calls [Fold`::fold_opt_ts_type_ann`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypeAnn>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type_ann`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ts_type_ann(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_ann(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<TsTypeAnn> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <Box<TsTypeAnn> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsTypeParamDecl>> {
-    #[doc = "Calls [Fold`::fold_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypeParamDecl>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ts_type_param_decl(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_decl(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<TsTypeParamDecl> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Box<TsTypeParamDecl> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsTypeParamInstantiation>> {
-    #[doc = "Calls [Fold`::fold_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypeParamInstantiation>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_ts_type_param_instantiation`] with `self`. \
+             (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_ts_type_param_instantiation(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_ts_type_param_instantiation(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <Box<TsTypeParamInstantiation> as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => {
+                <Box<TsTypeParamInstantiation> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                    inner, visitor, __ast_path,
+                )
+            }
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Option<VarDeclOrExpr> {
-    #[doc = "Calls [Fold`::fold_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<VarDeclOrExpr> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_var_decl_or_expr(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_var_decl_or_expr(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self.map(|inner| <VarDeclOrExpr as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        match self {
+            Some(inner) => <VarDeclOrExpr as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                inner, visitor, __ast_path,
+            ),
+            None => {}
+        }
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Option<ExprOrSpread>> {
-    #[doc = "Calls [Fold`::fold_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Option<ExprOrSpread>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_vec_expr_or_spreads(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_vec_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Option<ExprOrSpread> as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Option<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Option<Pat>> {
-    #[doc = "Calls [Fold`::fold_opt_vec_pats`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Option<Pat>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_vec_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_opt_vec_pats(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_opt_vec_pats(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Option<Pat> as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<ParamOrTsParamProp> {
-    #[doc = "Calls [Fold`::fold_param_or_ts_param_props`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ParamOrTsParamProp> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_param_or_ts_param_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_param_or_ts_param_props(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_param_or_ts_param_props(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <ParamOrTsParamProp as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <ParamOrTsParamProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Param> {
-    #[doc = "Calls [Fold`::fold_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Param> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_params(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Param as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Param as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Pat> {
-    #[doc = "Calls [Fold`::fold_pats`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Pat> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_pats(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_pats(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Pat as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<PropOrSpread> {
-    #[doc = "Calls [Fold`::fold_prop_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PropOrSpread> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_prop_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_prop_or_spreads(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_prop_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <PropOrSpread as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <PropOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
-    #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::Span {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_span(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        {}
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Stmt> {
-    #[doc = "Calls [Fold`::fold_stmts`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Stmt> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_stmts`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_stmts(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_stmts(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Stmt as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Stmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<SwitchCase> {
-    #[doc = "Calls [Fold`::fold_switch_cases`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SwitchCase> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_switch_cases`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_switch_cases(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_switch_cases(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <SwitchCase as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <SwitchCase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for swc_common::SyntaxContext {
-    #[doc = "Calls [Fold`::fold_syntax_context`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::SyntaxContext {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_syntax_context`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_syntax_context(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_syntax_context(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        self
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        {}
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<TplElement> {
-    #[doc = "Calls [Fold`::fold_tpl_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TplElement> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_tpl_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_tpl_elements(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_tpl_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <TplElement as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TplElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsEnumMember> {
-    #[doc = "Calls [Fold`::fold_ts_enum_members`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsEnumMember> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_enum_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_enum_members(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_enum_members(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <TsEnumMember as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsEnumMember as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsExprWithTypeArgs> {
-    #[doc = "Calls [Fold`::fold_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsExprWithTypeArgs> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_expr_with_type_argss(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_expr_with_type_argss(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <TsExprWithTypeArgs as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsExprWithTypeArgs as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsFnParam> {
-    #[doc = "Calls [Fold`::fold_ts_fn_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsFnParam> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_fn_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_fn_params(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_fn_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <TsFnParam as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsFnParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTupleElement> {
-    #[doc = "Calls [Fold`::fold_ts_tuple_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTupleElement> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_tuple_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_tuple_elements(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_tuple_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <TsTupleElement as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsTupleElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeElement> {
-    #[doc = "Calls [Fold`::fold_ts_type_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTypeElement> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_elements(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <TsTypeElement as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsTypeElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeParam> {
-    #[doc = "Calls [Fold`::fold_ts_type_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTypeParam> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_type_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_type_params(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_type_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <TsTypeParam as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <TsTypeParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<TsType>> {
-    #[doc = "Calls [Fold`::fold_ts_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Box<TsType>> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_ts_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_ts_types(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_ts_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <Box<TsType> as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V: ?Sized + Fold> FoldWith<V> for Vec<VarDeclarator> {
-    #[doc = "Calls [Fold`::fold_var_declarators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<VarDeclarator> {
+    #[doc = "Calls [VisitMutAstPath`::visit_mut_var_declarators`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        <V as Fold>::fold_var_declarators(visitor, self)
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        <V as VisitMutAstPath>::visit_mut_var_declarators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
-            <VarDeclarator as FoldWith<V>>::fold_with(item, visitor)
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        self.iter_mut().enumerate().for_each(|(__idx, item)| {
+            let mut __ast_path = __ast_path.with_index_guard(__idx);
+            <VarDeclarator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+                item,
+                visitor,
+                &mut *__ast_path,
+            )
         })
     }
 }
-impl<V, T> FoldWith<V> for std::boxed::Box<T>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> VisitMutWithAstPath<V> for std::boxed::Box<T>
 where
-    V: ?Sized + Fold,
-    T: FoldWith<V>,
+    V: ?Sized + VisitMutAstPath,
+    T: VisitMutWithAstPath<V>,
 {
     #[inline]
-    fn fold_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::map::Map::map(self, |inner| <T as FoldWith<V>>::fold_with(inner, visitor))
+    fn visit_mut_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        let v = <T as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
+            &mut **self,
+            visitor,
+            __ast_path,
+        );
+        v
     }
 
     #[inline]
-    fn fold_children_with(self, visitor: &mut V) -> Self {
-        swc_visit::util::map::Map::map(self, |inner| {
-            <T as FoldWith<V>>::fold_children_with(inner, visitor)
-        })
+    fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
+        let v = <T as VisitMutWithAstPath<V>>::visit_mut_children_with_ast_path(
+            &mut **self,
+            visitor,
+            __ast_path,
+        );
+        v
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait FoldAstPath {
+pub trait Fold {
     #[doc = "Visit a node of type `Accessibility`.\n\nBy default, this method calls \
-             [`Accessibility::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Accessibility::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_accessibility(
-        &mut self,
-        node: Accessibility,
-        __ast_path: &mut AstKindPath,
-    ) -> Accessibility {
-        <Accessibility as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
+        <Accessibility as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrayLit`.\n\nBy default, this method calls \
-             [`ArrayLit::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ArrayLit::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
-        <ArrayLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
+        <ArrayLit as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrayPat`.\n\nBy default, this method calls \
-             [`ArrayPat::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ArrayPat::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
-        <ArrayPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
+        <ArrayPat as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrowExpr`.\n\nBy default, this method calls \
-             [`ArrowExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ArrowExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
-        <ArrowExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
+        <ArrowExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignExpr`.\n\nBy default, this method calls \
-             [`AssignExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AssignExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
-        <AssignExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
+        <AssignExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignOp`.\n\nBy default, this method calls \
-             [`AssignOp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AssignOp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
-        <AssignOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
+        <AssignOp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignPat`.\n\nBy default, this method calls \
-             [`AssignPat::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AssignPat::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
-        <AssignPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
+        <AssignPat as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignPatProp`.\n\nBy default, this method calls \
-             [`AssignPatProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignPatProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_assign_pat_prop(
-        &mut self,
-        node: AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignPatProp {
-        <AssignPatProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
+        <AssignPatProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignProp`.\n\nBy default, this method calls \
-             [`AssignProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AssignProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
-        <AssignProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
+        <AssignProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignTarget`.\n\nBy default, this method calls \
-             [`AssignTarget::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignTarget::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_assign_target(
-        &mut self,
-        node: AssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTarget {
-        <AssignTarget as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
+        <AssignTarget as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignTargetPat`.\n\nBy default, this method calls \
-             [`AssignTargetPat::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AssignTargetPat::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_assign_target_pat(
-        &mut self,
-        node: AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTargetPat {
-        <AssignTargetPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
+        <AssignTargetPat as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`swc_atoms :: Atom::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
-        <swc_atoms::Atom as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+        <swc_atoms::Atom as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AutoAccessor`.\n\nBy default, this method calls \
-             [`AutoAccessor::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`AutoAccessor::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_auto_accessor(
-        &mut self,
-        node: AutoAccessor,
-        __ast_path: &mut AstKindPath,
-    ) -> AutoAccessor {
-        <AutoAccessor as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
+        <AutoAccessor as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AwaitExpr`.\n\nBy default, this method calls \
-             [`AwaitExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`AwaitExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
-        <AwaitExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
+        <AwaitExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BigInt`.\n\nBy default, this method calls \
-             [`BigInt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BigInt::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
-        <BigInt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
+        <BigInt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BigIntValue`.\n\nBy default, this method calls \
-             [`BigIntValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BigIntValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_big_int_value(
-        &mut self,
-        node: BigIntValue,
-        __ast_path: &mut AstKindPath,
-    ) -> BigIntValue {
-        <BigIntValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
+        <BigIntValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinExpr`.\n\nBy default, this method calls \
-             [`BinExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`BinExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
-        <BinExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
+        <BinExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinaryOp`.\n\nBy default, this method calls \
-             [`BinaryOp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`BinaryOp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
-        <BinaryOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
+        <BinaryOp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BindingIdent`.\n\nBy default, this method calls \
-             [`BindingIdent::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BindingIdent::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_binding_ident(
-        &mut self,
-        node: BindingIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> BindingIdent {
-        <BindingIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
+        <BindingIdent as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BlockStmt`.\n\nBy default, this method calls \
-             [`BlockStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`BlockStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
-        <BlockStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
+        <BlockStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BlockStmtOrExpr`.\n\nBy default, this method calls \
-             [`BlockStmtOrExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`BlockStmtOrExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_block_stmt_or_expr(
-        &mut self,
-        node: BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> BlockStmtOrExpr {
-        <BlockStmtOrExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
+        <BlockStmtOrExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Bool`.\n\nBy default, this method calls \
-             [`Bool::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Bool::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
-        <Bool as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_bool(&mut self, node: Bool) -> Bool {
+        <Bool as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `BreakStmt`.\n\nBy default, this method calls \
-             [`BreakStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`BreakStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
-        <BreakStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
+        <BreakStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CallExpr`.\n\nBy default, this method calls \
-             [`CallExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`CallExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
-        <CallExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
+        <CallExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Callee`.\n\nBy default, this method calls \
-             [`Callee::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Callee::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
-        <Callee as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_callee(&mut self, node: Callee) -> Callee {
+        <Callee as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CatchClause`.\n\nBy default, this method calls \
-             [`CatchClause::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`CatchClause::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_catch_clause(
-        &mut self,
-        node: CatchClause,
-        __ast_path: &mut AstKindPath,
-    ) -> CatchClause {
-        <CatchClause as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
+        <CatchClause as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Class`.\n\nBy default, this method calls \
-             [`Class::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Class::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
-        <Class as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_class(&mut self, node: Class) -> Class {
+        <Class as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassDecl`.\n\nBy default, this method calls \
-             [`ClassDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ClassDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
-        <ClassDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
+        <ClassDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassExpr`.\n\nBy default, this method calls \
-             [`ClassExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ClassExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
-        <ClassExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
+        <ClassExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassMember`.\n\nBy default, this method calls \
-             [`ClassMember::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ClassMember::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_class_member(
-        &mut self,
-        node: ClassMember,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMember {
-        <ClassMember as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
+        <ClassMember as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ClassMember >`.\n\nBy default, this method calls [`Vec < \
-             ClassMember >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             ClassMember >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_class_members(
-        &mut self,
-        node: Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ClassMember> {
-        <Vec<ClassMember> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
+        <Vec<ClassMember> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassMethod`.\n\nBy default, this method calls \
-             [`ClassMethod::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ClassMethod::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_class_method(
-        &mut self,
-        node: ClassMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMethod {
-        <ClassMethod as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
+        <ClassMethod as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassProp`.\n\nBy default, this method calls \
-             [`ClassProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ClassProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
-        <ClassProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
+        <ClassProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComputedPropName`.\n\nBy default, this method calls \
-             [`ComputedPropName::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ComputedPropName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_computed_prop_name(
-        &mut self,
-        node: ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) -> ComputedPropName {
-        <ComputedPropName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
+        <ComputedPropName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CondExpr`.\n\nBy default, this method calls \
-             [`CondExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`CondExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
-        <CondExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
+        <CondExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Constructor`.\n\nBy default, this method calls \
-             [`Constructor::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`Constructor::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
-        <Constructor as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
+        <Constructor as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContinueStmt`.\n\nBy default, this method calls \
-             [`ContinueStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ContinueStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_continue_stmt(
-        &mut self,
-        node: ContinueStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> ContinueStmt {
-        <ContinueStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
+        <ContinueStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DebuggerStmt`.\n\nBy default, this method calls \
-             [`DebuggerStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DebuggerStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_debugger_stmt(
-        &mut self,
-        node: DebuggerStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DebuggerStmt {
-        <DebuggerStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
+        <DebuggerStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Decl`.\n\nBy default, this method calls \
-             [`Decl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Decl::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
-        <Decl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_decl(&mut self, node: Decl) -> Decl {
+        <Decl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Decorator`.\n\nBy default, this method calls \
-             [`Decorator::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Decorator::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
-        <Decorator as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
+        <Decorator as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Decorator >`.\n\nBy default, this method calls [`Vec < \
-             Decorator >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             Decorator >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_decorators(
-        &mut self,
-        node: Vec<Decorator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Decorator> {
-        <Vec<Decorator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
+        <Vec<Decorator> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DefaultDecl`.\n\nBy default, this method calls \
-             [`DefaultDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DefaultDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_default_decl(
-        &mut self,
-        node: DefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> DefaultDecl {
-        <DefaultDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
+        <DefaultDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DoWhileStmt`.\n\nBy default, this method calls \
-             [`DoWhileStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`DoWhileStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_do_while_stmt(
-        &mut self,
-        node: DoWhileStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DoWhileStmt {
-        <DoWhileStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
+        <DoWhileStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `EmptyStmt`.\n\nBy default, this method calls \
-             [`EmptyStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`EmptyStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
-        <EmptyStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
+        <EmptyStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `EsVersion`.\n\nBy default, this method calls \
-             [`EsVersion::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`EsVersion::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
-        <EsVersion as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
+        <EsVersion as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportAll`.\n\nBy default, this method calls \
-             [`ExportAll::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ExportAll::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
-        <ExportAll as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
+        <ExportAll as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDecl`.\n\nBy default, this method calls \
-             [`ExportDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ExportDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
-        <ExportDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
+        <ExportDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultDecl`.\n\nBy default, this method calls \
-             [`ExportDefaultDecl::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ExportDefaultDecl::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_export_default_decl(
-        &mut self,
-        node: ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultDecl {
-        <ExportDefaultDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
+        <ExportDefaultDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultExpr`.\n\nBy default, this method calls \
-             [`ExportDefaultExpr::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ExportDefaultExpr::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_export_default_expr(
-        &mut self,
-        node: ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultExpr {
-        <ExportDefaultExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
+        <ExportDefaultExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ExportDefaultSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ExportDefaultSpecifier::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_export_default_specifier(
         &mut self,
         node: ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportDefaultSpecifier {
-        <ExportDefaultSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ExportDefaultSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamedSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ExportNamedSpecifier::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_export_named_specifier(
-        &mut self,
-        node: ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportNamedSpecifier {
-        <ExportNamedSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
+        <ExportNamedSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportNamespaceSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamespaceSpecifier::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`ExportNamespaceSpecifier::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_export_namespace_specifier(
         &mut self,
         node: ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportNamespaceSpecifier {
-        <ExportNamespaceSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ExportNamespaceSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportSpecifier`.\n\nBy default, this method calls \
-             [`ExportSpecifier::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExportSpecifier::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_export_specifier(
-        &mut self,
-        node: ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportSpecifier {
-        <ExportSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
+        <ExportSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ExportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ExportSpecifier >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < ExportSpecifier >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_export_specifiers(
-        &mut self,
-        node: Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExportSpecifier> {
-        <Vec<ExportSpecifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
+        <Vec<ExportSpecifier> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Expr`.\n\nBy default, this method calls \
-             [`Expr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Expr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
-        <Expr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_expr(&mut self, node: Expr) -> Expr {
+        <Expr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExprOrSpread`.\n\nBy default, this method calls \
-             [`ExprOrSpread::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ExprOrSpread::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_expr_or_spread(
-        &mut self,
-        node: ExprOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> ExprOrSpread {
-        <ExprOrSpread as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
+        <ExprOrSpread as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ExprOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             ExprOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             ExprOrSpread >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_expr_or_spreads(
-        &mut self,
-        node: Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExprOrSpread> {
-        <Vec<ExprOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
+        <Vec<ExprOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExprStmt`.\n\nBy default, this method calls \
-             [`ExprStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ExprStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
-        <ExprStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
+        <ExprStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Box < Expr > >`.\n\nBy default, this method calls [`Vec < \
-             Box < Expr > >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             Box < Expr > >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
-        <Vec<Box<Expr>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
+        <Vec<Box<Expr>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `FnDecl`.\n\nBy default, this method calls \
-             [`FnDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`FnDecl::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
-        <FnDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
+        <FnDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `FnExpr`.\n\nBy default, this method calls \
-             [`FnExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`FnExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
-        <FnExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
+        <FnExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForHead`.\n\nBy default, this method calls \
-             [`ForHead::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForHead::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
-        <ForHead as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
+        <ForHead as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForInStmt`.\n\nBy default, this method calls \
-             [`ForInStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ForInStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
-        <ForInStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
+        <ForInStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForOfStmt`.\n\nBy default, this method calls \
-             [`ForOfStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ForOfStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
-        <ForOfStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
+        <ForOfStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForStmt`.\n\nBy default, this method calls \
-             [`ForStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`ForStmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
-        <ForStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
+        <ForStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`Function::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
-        <Function as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_function(&mut self, node: Function) -> Function {
+        <Function as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `GetterProp`.\n\nBy default, this method calls \
-             [`GetterProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`GetterProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
-        <GetterProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
+        <GetterProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Ident::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
-        <Ident as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ident(&mut self, node: Ident) -> Ident {
+        <Ident as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `IdentName`.\n\nBy default, this method calls \
-             [`IdentName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`IdentName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
-        <IdentName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
+        <IdentName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `IfStmt`.\n\nBy default, this method calls \
-             [`IfStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`IfStmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
-        <IfStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
+        <IfStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Import`.\n\nBy default, this method calls \
-             [`Import::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Import::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
-        <Import as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_import(&mut self, node: Import) -> Import {
+        <Import as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportDecl`.\n\nBy default, this method calls \
-             [`ImportDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ImportDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
-        <ImportDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
+        <ImportDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ImportDefaultSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ImportDefaultSpecifier::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_import_default_specifier(
         &mut self,
         node: ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportDefaultSpecifier {
-        <ImportDefaultSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ImportDefaultSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ImportNamedSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ImportNamedSpecifier::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_import_named_specifier(
-        &mut self,
-        node: ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportNamedSpecifier {
-        <ImportNamedSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
+        <ImportNamedSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportPhase`.\n\nBy default, this method calls \
-             [`ImportPhase::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportPhase::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_phase(
-        &mut self,
-        node: ImportPhase,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPhase {
-        <ImportPhase as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
+        <ImportPhase as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportSpecifier`.\n\nBy default, this method calls \
-             [`ImportSpecifier::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportSpecifier::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_specifier(
-        &mut self,
-        node: ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportSpecifier {
-        <ImportSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
+        <ImportSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ImportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ImportSpecifier >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < ImportSpecifier >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_import_specifiers(
-        &mut self,
-        node: Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportSpecifier> {
-        <Vec<ImportSpecifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
+        <Vec<ImportSpecifier> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportStarAsSpecifier`.\n\nBy default, this method calls \
-             [`ImportStarAsSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`ImportStarAsSpecifier::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_import_star_as_specifier(
         &mut self,
         node: ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportStarAsSpecifier {
-        <ImportStarAsSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <ImportStarAsSpecifier as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportWith`.\n\nBy default, this method calls \
-             [`ImportWith::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
-    #[inline]
-    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
-        <ImportWith as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
-             [`ImportWithItem::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ImportWith::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_with_item(
-        &mut self,
-        node: ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportWithItem {
-        <ImportWithItem as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
+        <ImportWith as FoldWith<Self>>::fold_children_with(node, self)
+    }
+    #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
+             [`ImportWithItem::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
+    #[inline]
+    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
+        <ImportWithItem as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ImportWithItem >`.\n\nBy default, this method calls [`Vec \
-             < ImportWithItem >::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             < ImportWithItem >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_import_with_items(
-        &mut self,
-        node: Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportWithItem> {
-        <Vec<ImportWithItem> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
+        <Vec<ImportWithItem> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Invalid`.\n\nBy default, this method calls \
-             [`Invalid::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Invalid::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
-        <Invalid as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
+        <Invalid as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttr`.\n\nBy default, this method calls \
-             [`JSXAttr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXAttr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
-        <JSXAttr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
+        <JSXAttr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrName`.\n\nBy default, this method calls \
-             [`JSXAttrName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXAttrName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_attr_name(
-        &mut self,
-        node: JSXAttrName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrName {
-        <JSXAttrName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
+        <JSXAttrName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrOrSpread`.\n\nBy default, this method calls \
-             [`JSXAttrOrSpread::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXAttrOrSpread::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_attr_or_spread(
-        &mut self,
-        node: JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrOrSpread {
-        <JSXAttrOrSpread as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
+        <JSXAttrOrSpread as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < JSXAttrOrSpread >`.\n\nBy default, this method calls \
-             [`Vec < JSXAttrOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < JSXAttrOrSpread >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_jsx_attr_or_spreads(
-        &mut self,
-        node: Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXAttrOrSpread> {
-        <Vec<JSXAttrOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
+        <Vec<JSXAttrOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrValue`.\n\nBy default, this method calls \
-             [`JSXAttrValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXAttrValue::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_attr_value(
-        &mut self,
-        node: JSXAttrValue,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrValue {
-        <JSXAttrValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
+        <JSXAttrValue as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXClosingElement`.\n\nBy default, this method calls \
-             [`JSXClosingElement::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXClosingElement::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_jsx_closing_element(
-        &mut self,
-        node: JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingElement {
-        <JSXClosingElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
+        <JSXClosingElement as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXClosingFragment`.\n\nBy default, this method calls \
-             [`JSXClosingFragment::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXClosingFragment::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_jsx_closing_fragment(
-        &mut self,
-        node: JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingFragment {
-        <JSXClosingFragment as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
+        <JSXClosingFragment as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElement`.\n\nBy default, this method calls \
-             [`JSXElement::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXElement::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
-        <JSXElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
+        <JSXElement as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElementChild`.\n\nBy default, this method calls \
-             [`JSXElementChild::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXElementChild::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_element_child(
-        &mut self,
-        node: JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementChild {
-        <JSXElementChild as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
+        <JSXElementChild as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < JSXElementChild >`.\n\nBy default, this method calls \
-             [`Vec < JSXElementChild >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Vec < JSXElementChild >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_jsx_element_childs(
-        &mut self,
-        node: Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXElementChild> {
-        <Vec<JSXElementChild> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
+        <Vec<JSXElementChild> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElementName`.\n\nBy default, this method calls \
-             [`JSXElementName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXElementName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_element_name(
-        &mut self,
-        node: JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementName {
-        <JSXElementName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
+        <JSXElementName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXEmptyExpr`.\n\nBy default, this method calls \
-             [`JSXEmptyExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXEmptyExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_empty_expr(
-        &mut self,
-        node: JSXEmptyExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXEmptyExpr {
-        <JSXEmptyExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
+        <JSXEmptyExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXExpr`.\n\nBy default, this method calls \
-             [`JSXExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
-        <JSXExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
+        <JSXExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
-             [`JSXExprContainer::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXExprContainer::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_expr_container(
-        &mut self,
-        node: JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXExprContainer {
-        <JSXExprContainer as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
+        <JSXExprContainer as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXFragment`.\n\nBy default, this method calls \
-             [`JSXFragment::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXFragment::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_fragment(
-        &mut self,
-        node: JSXFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXFragment {
-        <JSXFragment as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
+        <JSXFragment as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXMemberExpr`.\n\nBy default, this method calls \
-             [`JSXMemberExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXMemberExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_member_expr(
-        &mut self,
-        node: JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXMemberExpr {
-        <JSXMemberExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
+        <JSXMemberExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXNamespacedName`.\n\nBy default, this method calls \
-             [`JSXNamespacedName::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXNamespacedName::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_jsx_namespaced_name(
-        &mut self,
-        node: JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXNamespacedName {
-        <JSXNamespacedName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
+        <JSXNamespacedName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXObject`.\n\nBy default, this method calls \
-             [`JSXObject::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`JSXObject::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
-        <JSXObject as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
+        <JSXObject as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXOpeningElement`.\n\nBy default, this method calls \
-             [`JSXOpeningElement::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXOpeningElement::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_jsx_opening_element(
-        &mut self,
-        node: JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningElement {
-        <JSXOpeningElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
+        <JSXOpeningElement as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXOpeningFragment`.\n\nBy default, this method calls \
-             [`JSXOpeningFragment::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`JSXOpeningFragment::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_jsx_opening_fragment(
-        &mut self,
-        node: JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningFragment {
-        <JSXOpeningFragment as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
+        <JSXOpeningFragment as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXSpreadChild`.\n\nBy default, this method calls \
-             [`JSXSpreadChild::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`JSXSpreadChild::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_jsx_spread_child(
-        &mut self,
-        node: JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXSpreadChild {
-        <JSXSpreadChild as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
+        <JSXSpreadChild as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXText`.\n\nBy default, this method calls \
-             [`JSXText::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`JSXText::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
-        <JSXText as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
+        <JSXText as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Key`.\n\nBy default, this method calls \
-             [`Key::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Key::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
-        <Key as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_key(&mut self, node: Key) -> Key {
+        <Key as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyValuePatProp`.\n\nBy default, this method calls \
-             [`KeyValuePatProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`KeyValuePatProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_key_value_pat_prop(
-        &mut self,
-        node: KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValuePatProp {
-        <KeyValuePatProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
+        <KeyValuePatProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyValueProp`.\n\nBy default, this method calls \
-             [`KeyValueProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`KeyValueProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_key_value_prop(
-        &mut self,
-        node: KeyValueProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValueProp {
-        <KeyValueProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
+        <KeyValueProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `LabeledStmt`.\n\nBy default, this method calls \
-             [`LabeledStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`LabeledStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_labeled_stmt(
-        &mut self,
-        node: LabeledStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> LabeledStmt {
-        <LabeledStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
+        <LabeledStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Lit`.\n\nBy default, this method calls \
-             [`Lit::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Lit::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
-        <Lit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_lit(&mut self, node: Lit) -> Lit {
+        <Lit as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MemberExpr`.\n\nBy default, this method calls \
-             [`MemberExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MemberExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
-        <MemberExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
+        <MemberExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MemberProp`.\n\nBy default, this method calls \
-             [`MemberProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MemberProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
-        <MemberProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
+        <MemberProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MetaPropExpr`.\n\nBy default, this method calls \
-             [`MetaPropExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MetaPropExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_meta_prop_expr(
-        &mut self,
-        node: MetaPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropExpr {
-        <MetaPropExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
+        <MetaPropExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MetaPropKind`.\n\nBy default, this method calls \
-             [`MetaPropKind::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`MetaPropKind::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_meta_prop_kind(
-        &mut self,
-        node: MetaPropKind,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropKind {
-        <MetaPropKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
+        <MetaPropKind as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MethodKind`.\n\nBy default, this method calls \
-             [`MethodKind::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MethodKind::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
-        <MethodKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
+        <MethodKind as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `MethodProp`.\n\nBy default, this method calls \
-             [`MethodProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`MethodProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
-        <MethodProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
+        <MethodProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Module`.\n\nBy default, this method calls \
-             [`Module::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Module::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
-        <Module as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_module(&mut self, node: Module) -> Module {
+        <Module as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleDecl`.\n\nBy default, this method calls \
-             [`ModuleDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ModuleDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
-        <ModuleDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
+        <ModuleDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleExportName`.\n\nBy default, this method calls \
-             [`ModuleExportName::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ModuleExportName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_module_export_name(
-        &mut self,
-        node: ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) -> ModuleExportName {
-        <ModuleExportName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
+        <ModuleExportName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleItem`.\n\nBy default, this method calls \
-             [`ModuleItem::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ModuleItem::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
-        <ModuleItem as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
+        <ModuleItem as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ModuleItem >`.\n\nBy default, this method calls [`Vec < \
-             ModuleItem >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             ModuleItem >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_module_items(
-        &mut self,
-        node: Vec<ModuleItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ModuleItem> {
-        <Vec<ModuleItem> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
+        <Vec<ModuleItem> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamedExport`.\n\nBy default, this method calls \
-             [`NamedExport::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`NamedExport::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_named_export(
-        &mut self,
-        node: NamedExport,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedExport {
-        <NamedExport as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
+        <NamedExport as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `NewExpr`.\n\nBy default, this method calls \
-             [`NewExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`NewExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
-        <NewExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
+        <NewExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Null`.\n\nBy default, this method calls \
-             [`Null::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Null::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
-        <Null as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_null(&mut self, node: Null) -> Null {
+        <Null as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Number::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
-        <Number as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_number(&mut self, node: Number) -> Number {
+        <Number as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectLit`.\n\nBy default, this method calls \
-             [`ObjectLit::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ObjectLit::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
-        <ObjectLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
+        <ObjectLit as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectPat`.\n\nBy default, this method calls \
-             [`ObjectPat::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ObjectPat::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
-        <ObjectPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
+        <ObjectPat as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectPatProp`.\n\nBy default, this method calls \
-             [`ObjectPatProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`ObjectPatProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_object_pat_prop(
-        &mut self,
-        node: ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ObjectPatProp {
-        <ObjectPatProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
+        <ObjectPatProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ObjectPatProp >`.\n\nBy default, this method calls [`Vec \
-             < ObjectPatProp >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             < ObjectPatProp >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_object_pat_props(
-        &mut self,
-        node: Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ObjectPatProp> {
-        <Vec<ObjectPatProp> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
+        <Vec<ObjectPatProp> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Accessibility >`.\n\nBy default, this method calls \
-             [`Option < Accessibility >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Accessibility >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_accessibility(
-        &mut self,
-        node: Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Accessibility> {
-        <Option<Accessibility> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
+        <Option<Accessibility> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < swc_atoms :: Atom >::fold_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
-        <Option<swc_atoms::Atom> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+        <Option<swc_atoms::Atom> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < BlockStmt >`.\n\nBy default, this method calls \
-             [`Option < BlockStmt >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < BlockStmt >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_block_stmt(
-        &mut self,
-        node: Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<BlockStmt> {
-        <Option<BlockStmt> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
+        <Option<BlockStmt> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptCall`.\n\nBy default, this method calls \
-             [`OptCall::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`OptCall::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
-        <OptCall as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
+        <OptCall as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
-             [`Option < CatchClause >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < CatchClause >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_catch_clause(
-        &mut self,
-        node: Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<CatchClause> {
-        <Option<CatchClause> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
+        <Option<CatchClause> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptChainBase`.\n\nBy default, this method calls \
-             [`OptChainBase::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`OptChainBase::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_chain_base(
-        &mut self,
-        node: OptChainBase,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainBase {
-        <OptChainBase as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
+        <OptChainBase as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptChainExpr`.\n\nBy default, this method calls \
-             [`OptChainExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`OptChainExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_chain_expr(
-        &mut self,
-        node: OptChainExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainExpr {
-        <OptChainExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
+        <OptChainExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Expr > >`.\n\nBy default, this method calls \
-             [`Option < Box < Expr > >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < Expr > >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_expr(
-        &mut self,
-        node: Option<Box<Expr>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Expr>> {
-        <Option<Box<Expr>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
+        <Option<Box<Expr>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ExprOrSpread >`.\n\nBy default, this method calls \
-             [`Option < ExprOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < ExprOrSpread >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_expr_or_spread(
-        &mut self,
-        node: Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ExprOrSpread> {
-        <Option<ExprOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
+        <Option<ExprOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Option < Vec < ExprOrSpread > >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Option < Vec < ExprOrSpread > >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_expr_or_spreads(
         &mut self,
         node: Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<ExprOrSpread>> {
-        <Option<Vec<ExprOrSpread>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Vec<ExprOrSpread>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             Ident >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
-        <Option<Ident> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+        <Option<Ident> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
-             [`Option < JSXAttrValue >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < JSXAttrValue >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_jsx_attr_value(
-        &mut self,
-        node: Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<JSXAttrValue> {
-        <Option<JSXAttrValue> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
+        <Option<JSXAttrValue> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < JSXClosingElement >`.\n\nBy default, this method calls \
-             [`Option < JSXClosingElement >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < JSXClosingElement >::fold_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
     fn fold_opt_jsx_closing_element(
         &mut self,
         node: Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<JSXClosingElement> {
-        <Option<JSXClosingElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<JSXClosingElement> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ModuleExportName >`.\n\nBy default, this method calls \
-             [`Option < ModuleExportName >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < ModuleExportName >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_opt_module_export_name(
         &mut self,
         node: Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ModuleExportName> {
-        <Option<ModuleExportName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<ModuleExportName> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ObjectLit > >`.\n\nBy default, this method calls \
-             [`Option < Box < ObjectLit > >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < ObjectLit > >::fold_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_opt_object_lit(
-        &mut self,
-        node: Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<ObjectLit>> {
-        <Option<Box<ObjectLit>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
+        <Option<Box<ObjectLit>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Pat >`.\n\nBy default, this method calls [`Option < \
-             Pat >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             Pat >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
-        <Option<Pat> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
+        <Option<Pat> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < swc_common :: Span >`.\n\nBy default, this method \
-             calls [`Option < swc_common :: Span >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             calls [`Option < swc_common :: Span >::fold_children_with`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn fold_opt_span(
-        &mut self,
-        node: Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_common::Span> {
-        <Option<swc_common::Span> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
+        <Option<swc_common::Span> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Stmt > >`.\n\nBy default, this method calls \
-             [`Option < Box < Stmt > >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < Stmt > >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_stmt(
-        &mut self,
-        node: Option<Box<Stmt>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Stmt>> {
-        <Option<Box<Stmt>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
+        <Option<Box<Stmt>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Str > >`.\n\nBy default, this method calls \
-             [`Option < Box < Str > >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < Box < Str > >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_str(
-        &mut self,
-        node: Option<Box<Str>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Str>> {
-        <Option<Box<Str>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
+        <Option<Box<Str>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TruePlusMinus >`.\n\nBy default, this method calls \
-             [`Option < TruePlusMinus >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < TruePlusMinus >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_true_plus_minus(
-        &mut self,
-        node: Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TruePlusMinus> {
-        <Option<TruePlusMinus> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
+        <Option<TruePlusMinus> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TsEntityName >`.\n\nBy default, this method calls \
-             [`Option < TsEntityName >::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`Option < TsEntityName >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_ts_entity_name(
-        &mut self,
-        node: Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TsEntityName> {
-        <Option<TsEntityName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
+        <Option<TsEntityName> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TsNamespaceBody >`.\n\nBy default, this method calls \
-             [`Option < TsNamespaceBody >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < TsNamespaceBody >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_opt_ts_namespace_body(
         &mut self,
         node: Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<TsNamespaceBody> {
-        <Option<TsNamespaceBody> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<TsNamespaceBody> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsType > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsType > >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < Box < TsType > >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn fold_opt_ts_type(
-        &mut self,
-        node: Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsType>> {
-        <Option<Box<TsType>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
+        <Option<Box<TsType>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeAnn > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsTypeAnn > >::fold_children_with_ast_path`]. If you want to \
-             recurse, you need to call it manually."]
+             [`Option < Box < TsTypeAnn > >::fold_children_with`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn fold_opt_ts_type_ann(
-        &mut self,
-        node: Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsTypeAnn>> {
-        <Option<Box<TsTypeAnn>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
+        <Option<Box<TsTypeAnn>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamDecl > >`.\n\nBy default, this method \
-             calls [`Option < Box < TsTypeParamDecl > >::fold_children_with_ast_path`]. If you \
-             want to recurse, you need to call it manually."]
+             calls [`Option < Box < TsTypeParamDecl > >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_ts_type_param_decl(
         &mut self,
         node: Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamDecl>> {
-        <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Option<Box<TsTypeParamDecl>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamInstantiation > >`.\n\nBy default, \
              this method calls [`Option < Box < TsTypeParamInstantiation > \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_ts_type_param_instantiation(
         &mut self,
         node: Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamInstantiation>> {
-        < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < Self > > :: fold_children_with_ast_path (node , self , __ast_path)
+        <Option<Box<TsTypeParamInstantiation>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < VarDeclOrExpr >`.\n\nBy default, this method calls \
-             [`Option < VarDeclOrExpr >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Option < VarDeclOrExpr >::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn fold_opt_var_decl_or_expr(
-        &mut self,
-        node: Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<VarDeclOrExpr> {
-        <Option<VarDeclOrExpr> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
+        <Option<VarDeclOrExpr> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Option < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Vec < Option < ExprOrSpread > >::fold_children_with_ast_path`]. If you want \
-             to recurse, you need to call it manually."]
+             calls [`Vec < Option < ExprOrSpread > >::fold_children_with`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
     fn fold_opt_vec_expr_or_spreads(
         &mut self,
         node: Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<Option<ExprOrSpread>> {
-        <Vec<Option<ExprOrSpread>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<Option<ExprOrSpread>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Option < Pat > >`.\n\nBy default, this method calls [`Vec \
-             < Option < Pat > >::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             < Option < Pat > >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_opt_vec_pats(
-        &mut self,
-        node: Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Option<Pat>> {
-        <Vec<Option<Pat>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
+        <Vec<Option<Pat>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Param`.\n\nBy default, this method calls \
-             [`Param::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Param::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
-        <Param as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_param(&mut self, node: Param) -> Param {
+        <Param as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ParamOrTsParamProp`.\n\nBy default, this method calls \
-             [`ParamOrTsParamProp::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`ParamOrTsParamProp::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_param_or_ts_param_prop(
-        &mut self,
-        node: ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ParamOrTsParamProp {
-        <ParamOrTsParamProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
+        <ParamOrTsParamProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ParamOrTsParamProp >`.\n\nBy default, this method calls \
-             [`Vec < ParamOrTsParamProp >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < ParamOrTsParamProp >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_param_or_ts_param_props(
         &mut self,
         node: Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ParamOrTsParamProp> {
-        <Vec<ParamOrTsParamProp> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<ParamOrTsParamProp> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Param >`.\n\nBy default, this method calls [`Vec < Param \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
-        <Vec<Param> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
+        <Vec<Param> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ParenExpr`.\n\nBy default, this method calls \
-             [`ParenExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ParenExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
-        <ParenExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
+        <ParenExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Pat`.\n\nBy default, this method calls \
-             [`Pat::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Pat::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
-        <Pat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_pat(&mut self, node: Pat) -> Pat {
+        <Pat as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Pat >`.\n\nBy default, this method calls [`Vec < Pat \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
-        <Vec<Pat> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
+        <Vec<Pat> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateMethod`.\n\nBy default, this method calls \
-             [`PrivateMethod::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`PrivateMethod::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_private_method(
-        &mut self,
-        node: PrivateMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateMethod {
-        <PrivateMethod as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
+        <PrivateMethod as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateName`.\n\nBy default, this method calls \
-             [`PrivateName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`PrivateName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_private_name(
-        &mut self,
-        node: PrivateName,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateName {
-        <PrivateName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
+        <PrivateName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateProp`.\n\nBy default, this method calls \
-             [`PrivateProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`PrivateProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_private_prop(
-        &mut self,
-        node: PrivateProp,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateProp {
-        <PrivateProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
+        <PrivateProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Program`.\n\nBy default, this method calls \
-             [`Program::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Program::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
-        <Program as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_program(&mut self, node: Program) -> Program {
+        <Program as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Prop`.\n\nBy default, this method calls \
-             [`Prop::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Prop::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
-        <Prop as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_prop(&mut self, node: Prop) -> Prop {
+        <Prop as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PropName`.\n\nBy default, this method calls \
-             [`PropName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`PropName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
-        <PropName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_prop_name(&mut self, node: PropName) -> PropName {
+        <PropName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `PropOrSpread`.\n\nBy default, this method calls \
-             [`PropOrSpread::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
-    #[inline]
-    fn fold_prop_or_spread(
-        &mut self,
-        node: PropOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> PropOrSpread {
-        <PropOrSpread as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
-    }
-    #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             PropOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`PropOrSpread::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_prop_or_spreads(
-        &mut self,
-        node: Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PropOrSpread> {
-        <Vec<PropOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
+        <PropOrSpread as FoldWith<Self>>::fold_children_with(node, self)
     }
-    #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
-             [`Regex::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+    #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
+             PropOrSpread >::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
     #[inline]
-    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
-        <Regex as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
+        <Vec<PropOrSpread> as FoldWith<Self>>::fold_children_with(node, self)
+    }
+    #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
+             [`Regex::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
+    fn fold_regex(&mut self, node: Regex) -> Regex {
+        <Regex as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `RestPat`.\n\nBy default, this method calls \
-             [`RestPat::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`RestPat::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
-        <RestPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
+        <RestPat as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ReturnStmt`.\n\nBy default, this method calls \
-             [`ReturnStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ReturnStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
-        <ReturnStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
+        <ReturnStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Script`.\n\nBy default, this method calls \
-             [`Script::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Script::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
-        <Script as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_script(&mut self, node: Script) -> Script {
+        <Script as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SeqExpr`.\n\nBy default, this method calls \
-             [`SeqExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`SeqExpr::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
-        <SeqExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
+        <SeqExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SetterProp`.\n\nBy default, this method calls \
-             [`SetterProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SetterProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
-        <SetterProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
+        <SetterProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SimpleAssignTarget`.\n\nBy default, this method calls \
-             [`SimpleAssignTarget::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`SimpleAssignTarget::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_simple_assign_target(
-        &mut self,
-        node: SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleAssignTarget {
-        <SimpleAssignTarget as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
+        <SimpleAssignTarget as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`swc_common :: Span::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
-        <swc_common::Span as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+        <swc_common::Span as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SpreadElement`.\n\nBy default, this method calls \
-             [`SpreadElement::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SpreadElement::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_spread_element(
-        &mut self,
-        node: SpreadElement,
-        __ast_path: &mut AstKindPath,
-    ) -> SpreadElement {
-        <SpreadElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
+        <SpreadElement as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `StaticBlock`.\n\nBy default, this method calls \
-             [`StaticBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`StaticBlock::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_static_block(
-        &mut self,
-        node: StaticBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> StaticBlock {
-        <StaticBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
+        <StaticBlock as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Stmt`.\n\nBy default, this method calls \
-             [`Stmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Stmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
-        <Stmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
+        <Stmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Stmt >`.\n\nBy default, this method calls [`Vec < Stmt \
-             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             >::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
-        <Vec<Stmt> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
+        <Vec<Stmt> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Str::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
-        <Str as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_str(&mut self, node: Str) -> Str {
+        <Str as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Super`.\n\nBy default, this method calls \
-             [`Super::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Super::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
-        <Super as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_super(&mut self, node: Super) -> Super {
+        <Super as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SuperProp`.\n\nBy default, this method calls \
-             [`SuperProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SuperProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
-        <SuperProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
+        <SuperProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SuperPropExpr`.\n\nBy default, this method calls \
-             [`SuperPropExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`SuperPropExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_super_prop_expr(
-        &mut self,
-        node: SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> SuperPropExpr {
-        <SuperPropExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
+        <SuperPropExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SwitchCase`.\n\nBy default, this method calls \
-             [`SwitchCase::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SwitchCase::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
-        <SwitchCase as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
+        <SwitchCase as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SwitchCase >`.\n\nBy default, this method calls [`Vec < \
-             SwitchCase >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             SwitchCase >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_switch_cases(
-        &mut self,
-        node: Vec<SwitchCase>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SwitchCase> {
-        <Vec<SwitchCase> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
+        <Vec<SwitchCase> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `SwitchStmt`.\n\nBy default, this method calls \
-             [`SwitchStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`SwitchStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
-        <SwitchStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
+        <SwitchStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_common :: SyntaxContext`.\n\nBy default, this method calls \
-             [`swc_common :: SyntaxContext::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`swc_common :: SyntaxContext::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_syntax_context(
         &mut self,
         node: swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
     ) -> swc_common::SyntaxContext {
-        <swc_common::SyntaxContext as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <swc_common::SyntaxContext as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TaggedTpl`.\n\nBy default, this method calls \
-             [`TaggedTpl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TaggedTpl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
-        <TaggedTpl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
+        <TaggedTpl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ThisExpr`.\n\nBy default, this method calls \
-             [`ThisExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ThisExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
-        <ThisExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
+        <ThisExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `ThrowStmt`.\n\nBy default, this method calls \
-             [`ThrowStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`ThrowStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
-        <ThrowStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
+        <ThrowStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Tpl`.\n\nBy default, this method calls \
-             [`Tpl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`Tpl::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
-        <Tpl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
+        <Tpl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TplElement`.\n\nBy default, this method calls \
-             [`TplElement::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TplElement::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
-        <TplElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
+        <TplElement as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TplElement >`.\n\nBy default, this method calls [`Vec < \
-             TplElement >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             TplElement >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_tpl_elements(
-        &mut self,
-        node: Vec<TplElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TplElement> {
-        <Vec<TplElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
+        <Vec<TplElement> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TruePlusMinus`.\n\nBy default, this method calls \
-             [`TruePlusMinus::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TruePlusMinus::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_true_plus_minus(
-        &mut self,
-        node: TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) -> TruePlusMinus {
-        <TruePlusMinus as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
+        <TruePlusMinus as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TryStmt`.\n\nBy default, this method calls \
-             [`TryStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TryStmt::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
-        <TryStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
+        <TryStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsArrayType`.\n\nBy default, this method calls \
-             [`TsArrayType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsArrayType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_array_type(
-        &mut self,
-        node: TsArrayType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsArrayType {
-        <TsArrayType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
+        <TsArrayType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsAsExpr`.\n\nBy default, this method calls \
-             [`TsAsExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsAsExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
-        <TsAsExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
+        <TsAsExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsCallSignatureDecl`.\n\nBy default, this method calls \
-             [`TsCallSignatureDecl::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsCallSignatureDecl::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_call_signature_decl(
-        &mut self,
-        node: TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsCallSignatureDecl {
-        <TsCallSignatureDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
+        <TsCallSignatureDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConditionalType`.\n\nBy default, this method calls \
-             [`TsConditionalType::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsConditionalType::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_conditional_type(
-        &mut self,
-        node: TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConditionalType {
-        <TsConditionalType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
+        <TsConditionalType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstAssertion`.\n\nBy default, this method calls \
-             [`TsConstAssertion::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsConstAssertion::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_const_assertion(
-        &mut self,
-        node: TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstAssertion {
-        <TsConstAssertion as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
+        <TsConstAssertion as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstructSignatureDecl`.\n\nBy default, this method calls \
-             [`TsConstructSignatureDecl::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsConstructSignatureDecl::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_ts_construct_signature_decl(
         &mut self,
         node: TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsConstructSignatureDecl {
-        <TsConstructSignatureDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <TsConstructSignatureDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstructorType`.\n\nBy default, this method calls \
-             [`TsConstructorType::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsConstructorType::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_constructor_type(
-        &mut self,
-        node: TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstructorType {
-        <TsConstructorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
+        <TsConstructorType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEntityName`.\n\nBy default, this method calls \
-             [`TsEntityName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsEntityName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_entity_name(
-        &mut self,
-        node: TsEntityName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEntityName {
-        <TsEntityName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
+        <TsEntityName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumDecl`.\n\nBy default, this method calls \
-             [`TsEnumDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsEnumDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
-        <TsEnumDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
+        <TsEnumDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumMember`.\n\nBy default, this method calls \
-             [`TsEnumMember::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsEnumMember::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_enum_member(
-        &mut self,
-        node: TsEnumMember,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMember {
-        <TsEnumMember as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
+        <TsEnumMember as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumMemberId`.\n\nBy default, this method calls \
-             [`TsEnumMemberId::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsEnumMemberId::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_enum_member_id(
-        &mut self,
-        node: TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMemberId {
-        <TsEnumMemberId as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
+        <TsEnumMemberId as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsEnumMember >`.\n\nBy default, this method calls [`Vec < \
-             TsEnumMember >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             TsEnumMember >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_enum_members(
-        &mut self,
-        node: Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsEnumMember> {
-        <Vec<TsEnumMember> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
+        <Vec<TsEnumMember> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExportAssignment`.\n\nBy default, this method calls \
-             [`TsExportAssignment::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsExportAssignment::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_export_assignment(
-        &mut self,
-        node: TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExportAssignment {
-        <TsExportAssignment as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
+        <TsExportAssignment as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExprWithTypeArgs`.\n\nBy default, this method calls \
-             [`TsExprWithTypeArgs::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsExprWithTypeArgs::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_expr_with_type_args(
-        &mut self,
-        node: TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExprWithTypeArgs {
-        <TsExprWithTypeArgs as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
+        <TsExprWithTypeArgs as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsExprWithTypeArgs >`.\n\nBy default, this method calls \
-             [`Vec < TsExprWithTypeArgs >::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`Vec < TsExprWithTypeArgs >::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_ts_expr_with_type_argss(
         &mut self,
         node: Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<TsExprWithTypeArgs> {
-        <Vec<TsExprWithTypeArgs> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <Vec<TsExprWithTypeArgs> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExternalModuleRef`.\n\nBy default, this method calls \
-             [`TsExternalModuleRef::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsExternalModuleRef::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_external_module_ref(
-        &mut self,
-        node: TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExternalModuleRef {
-        <TsExternalModuleRef as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
+        <TsExternalModuleRef as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnOrConstructorType`.\n\nBy default, this method calls \
-             [`TsFnOrConstructorType::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsFnOrConstructorType::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_ts_fn_or_constructor_type(
         &mut self,
         node: TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
     ) -> TsFnOrConstructorType {
-        <TsFnOrConstructorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <TsFnOrConstructorType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnParam`.\n\nBy default, this method calls \
-             [`TsFnParam::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsFnParam::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
-        <TsFnParam as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
+        <TsFnParam as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsFnParam >`.\n\nBy default, this method calls [`Vec < \
-             TsFnParam >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             TsFnParam >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_fn_params(
-        &mut self,
-        node: Vec<TsFnParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsFnParam> {
-        <Vec<TsFnParam> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
+        <Vec<TsFnParam> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnType`.\n\nBy default, this method calls \
-             [`TsFnType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsFnType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
-        <TsFnType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
+        <TsFnType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsGetterSignature`.\n\nBy default, this method calls \
-             [`TsGetterSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsGetterSignature::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_getter_signature(
-        &mut self,
-        node: TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsGetterSignature {
-        <TsGetterSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
+        <TsGetterSignature as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsImportEqualsDecl`.\n\nBy default, this method calls \
-             [`TsImportEqualsDecl::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsImportEqualsDecl::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_import_equals_decl(
-        &mut self,
-        node: TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportEqualsDecl {
-        <TsImportEqualsDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
+        <TsImportEqualsDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsImportType`.\n\nBy default, this method calls \
-             [`TsImportType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsImportType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_import_type(
-        &mut self,
-        node: TsImportType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportType {
-        <TsImportType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
+        <TsImportType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIndexSignature`.\n\nBy default, this method calls \
-             [`TsIndexSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsIndexSignature::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_index_signature(
-        &mut self,
-        node: TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexSignature {
-        <TsIndexSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
+        <TsIndexSignature as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIndexedAccessType`.\n\nBy default, this method calls \
-             [`TsIndexedAccessType::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsIndexedAccessType::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_indexed_access_type(
-        &mut self,
-        node: TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexedAccessType {
-        <TsIndexedAccessType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
+        <TsIndexedAccessType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInferType`.\n\nBy default, this method calls \
-             [`TsInferType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsInferType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_infer_type(
-        &mut self,
-        node: TsInferType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInferType {
-        <TsInferType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
+        <TsInferType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInstantiation`.\n\nBy default, this method calls \
-             [`TsInstantiation::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsInstantiation::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_instantiation(
-        &mut self,
-        node: TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInstantiation {
-        <TsInstantiation as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
+        <TsInstantiation as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInterfaceBody`.\n\nBy default, this method calls \
-             [`TsInterfaceBody::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsInterfaceBody::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_interface_body(
-        &mut self,
-        node: TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceBody {
-        <TsInterfaceBody as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
+        <TsInterfaceBody as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInterfaceDecl`.\n\nBy default, this method calls \
-             [`TsInterfaceDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsInterfaceDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_interface_decl(
-        &mut self,
-        node: TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceDecl {
-        <TsInterfaceDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
+        <TsInterfaceDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIntersectionType`.\n\nBy default, this method calls \
-             [`TsIntersectionType::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsIntersectionType::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_intersection_type(
-        &mut self,
-        node: TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIntersectionType {
-        <TsIntersectionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
+        <TsIntersectionType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsKeywordType`.\n\nBy default, this method calls \
-             [`TsKeywordType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsKeywordType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_keyword_type(
-        &mut self,
-        node: TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordType {
-        <TsKeywordType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
+        <TsKeywordType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsKeywordTypeKind`.\n\nBy default, this method calls \
-             [`TsKeywordTypeKind::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsKeywordTypeKind::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_keyword_type_kind(
-        &mut self,
-        node: TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordTypeKind {
-        <TsKeywordTypeKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
+        <TsKeywordTypeKind as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsLit`.\n\nBy default, this method calls \
-             [`TsLit::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsLit::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
-        <TsLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
+        <TsLit as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsLitType`.\n\nBy default, this method calls \
-             [`TsLitType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsLitType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
-        <TsLitType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
+        <TsLitType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsMappedType`.\n\nBy default, this method calls \
-             [`TsMappedType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsMappedType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_mapped_type(
-        &mut self,
-        node: TsMappedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMappedType {
-        <TsMappedType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
+        <TsMappedType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsMethodSignature`.\n\nBy default, this method calls \
-             [`TsMethodSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsMethodSignature::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_method_signature(
-        &mut self,
-        node: TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMethodSignature {
-        <TsMethodSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
+        <TsMethodSignature as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleBlock`.\n\nBy default, this method calls \
-             [`TsModuleBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsModuleBlock::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_module_block(
-        &mut self,
-        node: TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleBlock {
-        <TsModuleBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
+        <TsModuleBlock as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleDecl`.\n\nBy default, this method calls \
-             [`TsModuleDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsModuleDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_module_decl(
-        &mut self,
-        node: TsModuleDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleDecl {
-        <TsModuleDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
+        <TsModuleDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleName`.\n\nBy default, this method calls \
-             [`TsModuleName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsModuleName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_module_name(
-        &mut self,
-        node: TsModuleName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleName {
-        <TsModuleName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
+        <TsModuleName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleRef`.\n\nBy default, this method calls \
-             [`TsModuleRef::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsModuleRef::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_module_ref(
-        &mut self,
-        node: TsModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleRef {
-        <TsModuleRef as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
+        <TsModuleRef as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceBody`.\n\nBy default, this method calls \
-             [`TsNamespaceBody::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsNamespaceBody::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_namespace_body(
-        &mut self,
-        node: TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceBody {
-        <TsNamespaceBody as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
+        <TsNamespaceBody as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsNamespaceDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_namespace_decl(
-        &mut self,
-        node: TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceDecl {
-        <TsNamespaceDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
+        <TsNamespaceDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceExportDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceExportDecl::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsNamespaceExportDecl::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_ts_namespace_export_decl(
         &mut self,
         node: TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsNamespaceExportDecl {
-        <TsNamespaceExportDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <TsNamespaceExportDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNonNullExpr`.\n\nBy default, this method calls \
-             [`TsNonNullExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsNonNullExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_non_null_expr(
-        &mut self,
-        node: TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNonNullExpr {
-        <TsNonNullExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
+        <TsNonNullExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsOptionalType`.\n\nBy default, this method calls \
-             [`TsOptionalType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsOptionalType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_optional_type(
-        &mut self,
-        node: TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsOptionalType {
-        <TsOptionalType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
+        <TsOptionalType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParamProp`.\n\nBy default, this method calls \
-             [`TsParamProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsParamProp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_param_prop(
-        &mut self,
-        node: TsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamProp {
-        <TsParamProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
+        <TsParamProp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParamPropParam`.\n\nBy default, this method calls \
-             [`TsParamPropParam::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsParamPropParam::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_param_prop_param(
-        &mut self,
-        node: TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamPropParam {
-        <TsParamPropParam as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
+        <TsParamPropParam as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParenthesizedType`.\n\nBy default, this method calls \
-             [`TsParenthesizedType::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsParenthesizedType::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_parenthesized_type(
-        &mut self,
-        node: TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParenthesizedType {
-        <TsParenthesizedType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
+        <TsParenthesizedType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsPropertySignature`.\n\nBy default, this method calls \
-             [`TsPropertySignature::fold_children_with_ast_path`]. If you want to recurse, you \
-             need to call it manually."]
+             [`TsPropertySignature::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_property_signature(
-        &mut self,
-        node: TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsPropertySignature {
-        <TsPropertySignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
+        <TsPropertySignature as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsQualifiedName`.\n\nBy default, this method calls \
-             [`TsQualifiedName::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsQualifiedName::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_qualified_name(
-        &mut self,
-        node: TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsQualifiedName {
-        <TsQualifiedName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
+        <TsQualifiedName as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsRestType`.\n\nBy default, this method calls \
-             [`TsRestType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsRestType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
-        <TsRestType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
+        <TsRestType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsSatisfiesExpr`.\n\nBy default, this method calls \
-             [`TsSatisfiesExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsSatisfiesExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_satisfies_expr(
-        &mut self,
-        node: TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSatisfiesExpr {
-        <TsSatisfiesExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
+        <TsSatisfiesExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsSetterSignature`.\n\nBy default, this method calls \
-             [`TsSetterSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsSetterSignature::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_setter_signature(
-        &mut self,
-        node: TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSetterSignature {
-        <TsSetterSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
+        <TsSetterSignature as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsThisType`.\n\nBy default, this method calls \
-             [`TsThisType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsThisType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
-        <TsThisType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
+        <TsThisType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsThisTypeOrIdent`.\n\nBy default, this method calls \
-             [`TsThisTypeOrIdent::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsThisTypeOrIdent::fold_children_with`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn fold_ts_this_type_or_ident(
-        &mut self,
-        node: TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> TsThisTypeOrIdent {
-        <TsThisTypeOrIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
+        <TsThisTypeOrIdent as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTplLitType`.\n\nBy default, this method calls \
-             [`TsTplLitType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTplLitType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_tpl_lit_type(
-        &mut self,
-        node: TsTplLitType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTplLitType {
-        <TsTplLitType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
+        <TsTplLitType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTupleElement`.\n\nBy default, this method calls \
-             [`TsTupleElement::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTupleElement::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_tuple_element(
-        &mut self,
-        node: TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleElement {
-        <TsTupleElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
+        <TsTupleElement as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTupleElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTupleElement >::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             < TsTupleElement >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_tuple_elements(
-        &mut self,
-        node: Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTupleElement> {
-        <Vec<TsTupleElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
+        <Vec<TsTupleElement> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTupleType`.\n\nBy default, this method calls \
-             [`TsTupleType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTupleType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_tuple_type(
-        &mut self,
-        node: TsTupleType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleType {
-        <TsTupleType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
+        <TsTupleType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsType`.\n\nBy default, this method calls \
-             [`TsType::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`TsType::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
-        <TsType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_type(&mut self, node: TsType) -> TsType {
+        <TsType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAliasDecl`.\n\nBy default, this method calls \
-             [`TsTypeAliasDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeAliasDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_alias_decl(
-        &mut self,
-        node: TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAliasDecl {
-        <TsTypeAliasDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
+        <TsTypeAliasDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAnn`.\n\nBy default, this method calls \
-             [`TsTypeAnn::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsTypeAnn::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
-        <TsTypeAnn as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
+        <TsTypeAnn as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAssertion`.\n\nBy default, this method calls \
-             [`TsTypeAssertion::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeAssertion::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_assertion(
-        &mut self,
-        node: TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAssertion {
-        <TsTypeAssertion as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
+        <TsTypeAssertion as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeElement`.\n\nBy default, this method calls \
-             [`TsTypeElement::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeElement::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_element(
-        &mut self,
-        node: TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeElement {
-        <TsTypeElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
+        <TsTypeElement as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTypeElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTypeElement >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             < TsTypeElement >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_elements(
-        &mut self,
-        node: Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeElement> {
-        <Vec<TsTypeElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
+        <Vec<TsTypeElement> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeLit`.\n\nBy default, this method calls \
-             [`TsTypeLit::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsTypeLit::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
-        <TsTypeLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
+        <TsTypeLit as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeOperator`.\n\nBy default, this method calls \
-             [`TsTypeOperator::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeOperator::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_operator(
-        &mut self,
-        node: TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperator {
-        <TsTypeOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
+        <TsTypeOperator as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeOperatorOp`.\n\nBy default, this method calls \
-             [`TsTypeOperatorOp::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             [`TsTypeOperatorOp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_operator_op(
-        &mut self,
-        node: TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperatorOp {
-        <TsTypeOperatorOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
+        <TsTypeOperatorOp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParam`.\n\nBy default, this method calls \
-             [`TsTypeParam::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeParam::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_param(
-        &mut self,
-        node: TsTypeParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParam {
-        <TsTypeParam as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
+        <TsTypeParam as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParamDecl`.\n\nBy default, this method calls \
-             [`TsTypeParamDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeParamDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_param_decl(
-        &mut self,
-        node: TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParamDecl {
-        <TsTypeParamDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
+        <TsTypeParamDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParamInstantiation`.\n\nBy default, this method calls \
-             [`TsTypeParamInstantiation::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsTypeParamInstantiation::fold_children_with`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
     fn fold_ts_type_param_instantiation(
         &mut self,
         node: TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
     ) -> TsTypeParamInstantiation {
-        <TsTypeParamInstantiation as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <TsTypeParamInstantiation as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTypeParam >`.\n\nBy default, this method calls [`Vec < \
-             TsTypeParam >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             TsTypeParam >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_params(
-        &mut self,
-        node: Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeParam> {
-        <Vec<TsTypeParam> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
+        <Vec<TsTypeParam> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypePredicate`.\n\nBy default, this method calls \
-             [`TsTypePredicate::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypePredicate::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_predicate(
-        &mut self,
-        node: TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypePredicate {
-        <TsTypePredicate as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
+        <TsTypePredicate as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeQuery`.\n\nBy default, this method calls \
-             [`TsTypeQuery::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeQuery::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_query(
-        &mut self,
-        node: TsTypeQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQuery {
-        <TsTypeQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
+        <TsTypeQuery as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeQueryExpr`.\n\nBy default, this method calls \
-             [`TsTypeQueryExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsTypeQueryExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_query_expr(
-        &mut self,
-        node: TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQueryExpr {
-        <TsTypeQueryExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
+        <TsTypeQueryExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeRef`.\n\nBy default, this method calls \
-             [`TsTypeRef::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`TsTypeRef::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
-        <TsTypeRef as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
+        <TsTypeRef as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Box < TsType > >`.\n\nBy default, this method calls [`Vec \
-             < Box < TsType > >::fold_children_with_ast_path`]. If you want to recurse, you need \
-             to call it manually."]
+             < Box < TsType > >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_types(
-        &mut self,
-        node: Vec<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Box<TsType>> {
-        <Vec<Box<TsType>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
+        <Vec<Box<TsType>> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsUnionOrIntersectionType`.\n\nBy default, this method calls \
-             [`TsUnionOrIntersectionType::fold_children_with_ast_path`]. If you want to recurse, \
-             you need to call it manually."]
+             [`TsUnionOrIntersectionType::fold_children_with`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
     fn fold_ts_union_or_intersection_type(
         &mut self,
         node: TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
     ) -> TsUnionOrIntersectionType {
-        <TsUnionOrIntersectionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+        <TsUnionOrIntersectionType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsUnionType`.\n\nBy default, this method calls \
-             [`TsUnionType::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`TsUnionType::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_ts_union_type(
-        &mut self,
-        node: TsUnionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsUnionType {
-        <TsUnionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
+        <TsUnionType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnaryExpr`.\n\nBy default, this method calls \
-             [`UnaryExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`UnaryExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
-        <UnaryExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
+        <UnaryExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnaryOp`.\n\nBy default, this method calls \
-             [`UnaryOp::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`UnaryOp::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
-        <UnaryOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
+        <UnaryOp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UpdateExpr`.\n\nBy default, this method calls \
-             [`UpdateExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`UpdateExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
-        <UpdateExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
+        <UpdateExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UpdateOp`.\n\nBy default, this method calls \
-             [`UpdateOp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`UpdateOp::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
-        <UpdateOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
+        <UpdateOp as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `UsingDecl`.\n\nBy default, this method calls \
-             [`UsingDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`UsingDecl::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
-        <UsingDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
+        <UsingDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDecl`.\n\nBy default, this method calls \
-             [`VarDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
-             manually."]
+             [`VarDecl::fold_children_with`]. If you want to recurse, you need to call it manually."]
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
-        <VarDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
+        <VarDecl as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclKind`.\n\nBy default, this method calls \
-             [`VarDeclKind::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`VarDeclKind::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_var_decl_kind(
-        &mut self,
-        node: VarDeclKind,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclKind {
-        <VarDeclKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
+        <VarDeclKind as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclOrExpr`.\n\nBy default, this method calls \
-             [`VarDeclOrExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`VarDeclOrExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_var_decl_or_expr(
-        &mut self,
-        node: VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclOrExpr {
-        <VarDeclOrExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
+        <VarDeclOrExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclarator`.\n\nBy default, this method calls \
-             [`VarDeclarator::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             [`VarDeclarator::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_var_declarator(
-        &mut self,
-        node: VarDeclarator,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclarator {
-        <VarDeclarator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
+        <VarDeclarator as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < VarDeclarator >`.\n\nBy default, this method calls [`Vec \
-             < VarDeclarator >::fold_children_with_ast_path`]. If you want to recurse, you need to \
-             call it manually."]
+             < VarDeclarator >::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_var_declarators(
-        &mut self,
-        node: Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<VarDeclarator> {
-        <Vec<VarDeclarator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
-            node, self, __ast_path,
-        )
+    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
+        <Vec<VarDeclarator> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `WhileStmt`.\n\nBy default, this method calls \
-             [`WhileStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`WhileStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
-        <WhileStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
+        <WhileStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `WithStmt`.\n\nBy default, this method calls \
-             [`WithStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`WithStmt::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
-        <WithStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
+        <WithStmt as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `YieldExpr`.\n\nBy default, this method calls \
-             [`YieldExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
-             it manually."]
+             [`YieldExpr::fold_children_with`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
-        <YieldExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
+    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
+        <YieldExpr as FoldWith<Self>>::fold_children_with(node, self)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> FoldAstPath for &mut V
+impl<V> Fold for &mut V
 where
-    V: ?Sized + FoldAstPath,
+    V: ?Sized + Fold,
 {
     #[inline]
-    fn fold_accessibility(
-        &mut self,
-        node: Accessibility,
-        __ast_path: &mut AstKindPath,
-    ) -> Accessibility {
-        <V as FoldAstPath>::fold_accessibility(&mut **self, node, __ast_path)
+    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
+        <V as Fold>::fold_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
-        <V as FoldAstPath>::fold_array_lit(&mut **self, node, __ast_path)
+    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
+        <V as Fold>::fold_array_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
-        <V as FoldAstPath>::fold_array_pat(&mut **self, node, __ast_path)
+    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
+        <V as Fold>::fold_array_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
-        <V as FoldAstPath>::fold_arrow_expr(&mut **self, node, __ast_path)
+    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
+        <V as Fold>::fold_arrow_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
-        <V as FoldAstPath>::fold_assign_expr(&mut **self, node, __ast_path)
+    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
+        <V as Fold>::fold_assign_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
-        <V as FoldAstPath>::fold_assign_op(&mut **self, node, __ast_path)
+    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
+        <V as Fold>::fold_assign_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
-        <V as FoldAstPath>::fold_assign_pat(&mut **self, node, __ast_path)
+    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
+        <V as Fold>::fold_assign_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_pat_prop(
-        &mut self,
-        node: AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignPatProp {
-        <V as FoldAstPath>::fold_assign_pat_prop(&mut **self, node, __ast_path)
+    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
+        <V as Fold>::fold_assign_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
-        <V as FoldAstPath>::fold_assign_prop(&mut **self, node, __ast_path)
+    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
+        <V as Fold>::fold_assign_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_target(
-        &mut self,
-        node: AssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTarget {
-        <V as FoldAstPath>::fold_assign_target(&mut **self, node, __ast_path)
+    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
+        <V as Fold>::fold_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_target_pat(
-        &mut self,
-        node: AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTargetPat {
-        <V as FoldAstPath>::fold_assign_target_pat(&mut **self, node, __ast_path)
+    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
+        <V as Fold>::fold_assign_target_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
-        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+        <V as Fold>::fold_atom(&mut **self, node)
     }
 
     #[inline]
-    fn fold_auto_accessor(
-        &mut self,
-        node: AutoAccessor,
-        __ast_path: &mut AstKindPath,
-    ) -> AutoAccessor {
-        <V as FoldAstPath>::fold_auto_accessor(&mut **self, node, __ast_path)
+    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
+        <V as Fold>::fold_auto_accessor(&mut **self, node)
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
-        <V as FoldAstPath>::fold_await_expr(&mut **self, node, __ast_path)
+    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
+        <V as Fold>::fold_await_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
-        <V as FoldAstPath>::fold_big_int(&mut **self, node, __ast_path)
+    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
+        <V as Fold>::fold_big_int(&mut **self, node)
     }
 
     #[inline]
-    fn fold_big_int_value(
-        &mut self,
-        node: BigIntValue,
-        __ast_path: &mut AstKindPath,
-    ) -> BigIntValue {
-        <V as FoldAstPath>::fold_big_int_value(&mut **self, node, __ast_path)
+    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
+        <V as Fold>::fold_big_int_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
-        <V as FoldAstPath>::fold_bin_expr(&mut **self, node, __ast_path)
+    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
+        <V as Fold>::fold_bin_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
-        <V as FoldAstPath>::fold_binary_op(&mut **self, node, __ast_path)
+    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
+        <V as Fold>::fold_binary_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_binding_ident(
-        &mut self,
-        node: BindingIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> BindingIdent {
-        <V as FoldAstPath>::fold_binding_ident(&mut **self, node, __ast_path)
+    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
+        <V as Fold>::fold_binding_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
-        <V as FoldAstPath>::fold_block_stmt(&mut **self, node, __ast_path)
+    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
+        <V as Fold>::fold_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(
-        &mut self,
-        node: BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> BlockStmtOrExpr {
-        <V as FoldAstPath>::fold_block_stmt_or_expr(&mut **self, node, __ast_path)
+    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
+        <V as Fold>::fold_block_stmt_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
-        <V as FoldAstPath>::fold_bool(&mut **self, node, __ast_path)
+    fn fold_bool(&mut self, node: Bool) -> Bool {
+        <V as Fold>::fold_bool(&mut **self, node)
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
-        <V as FoldAstPath>::fold_break_stmt(&mut **self, node, __ast_path)
+    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
+        <V as Fold>::fold_break_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
-        <V as FoldAstPath>::fold_call_expr(&mut **self, node, __ast_path)
+    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
+        <V as Fold>::fold_call_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
-        <V as FoldAstPath>::fold_callee(&mut **self, node, __ast_path)
+    fn fold_callee(&mut self, node: Callee) -> Callee {
+        <V as Fold>::fold_callee(&mut **self, node)
     }
 
     #[inline]
-    fn fold_catch_clause(
-        &mut self,
-        node: CatchClause,
-        __ast_path: &mut AstKindPath,
-    ) -> CatchClause {
-        <V as FoldAstPath>::fold_catch_clause(&mut **self, node, __ast_path)
+    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
+        <V as Fold>::fold_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
-        <V as FoldAstPath>::fold_class(&mut **self, node, __ast_path)
+    fn fold_class(&mut self, node: Class) -> Class {
+        <V as Fold>::fold_class(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
-        <V as FoldAstPath>::fold_class_decl(&mut **self, node, __ast_path)
+    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
+        <V as Fold>::fold_class_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
-        <V as FoldAstPath>::fold_class_expr(&mut **self, node, __ast_path)
+    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
+        <V as Fold>::fold_class_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_member(
-        &mut self,
-        node: ClassMember,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMember {
-        <V as FoldAstPath>::fold_class_member(&mut **self, node, __ast_path)
+    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
+        <V as Fold>::fold_class_member(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_members(
-        &mut self,
-        node: Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ClassMember> {
-        <V as FoldAstPath>::fold_class_members(&mut **self, node, __ast_path)
+    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
+        <V as Fold>::fold_class_members(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_method(
-        &mut self,
-        node: ClassMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMethod {
-        <V as FoldAstPath>::fold_class_method(&mut **self, node, __ast_path)
+    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
+        <V as Fold>::fold_class_method(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
-        <V as FoldAstPath>::fold_class_prop(&mut **self, node, __ast_path)
+    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
+        <V as Fold>::fold_class_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_computed_prop_name(
-        &mut self,
-        node: ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) -> ComputedPropName {
-        <V as FoldAstPath>::fold_computed_prop_name(&mut **self, node, __ast_path)
+    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
+        <V as Fold>::fold_computed_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
-        <V as FoldAstPath>::fold_cond_expr(&mut **self, node, __ast_path)
+    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
+        <V as Fold>::fold_cond_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
-        <V as FoldAstPath>::fold_constructor(&mut **self, node, __ast_path)
+    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
+        <V as Fold>::fold_constructor(&mut **self, node)
     }
 
     #[inline]
-    fn fold_continue_stmt(
-        &mut self,
-        node: ContinueStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> ContinueStmt {
-        <V as FoldAstPath>::fold_continue_stmt(&mut **self, node, __ast_path)
+    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
+        <V as Fold>::fold_continue_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_debugger_stmt(
-        &mut self,
-        node: DebuggerStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DebuggerStmt {
-        <V as FoldAstPath>::fold_debugger_stmt(&mut **self, node, __ast_path)
+    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
+        <V as Fold>::fold_debugger_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
-        <V as FoldAstPath>::fold_decl(&mut **self, node, __ast_path)
+    fn fold_decl(&mut self, node: Decl) -> Decl {
+        <V as Fold>::fold_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
-        <V as FoldAstPath>::fold_decorator(&mut **self, node, __ast_path)
+    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
+        <V as Fold>::fold_decorator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_decorators(
-        &mut self,
-        node: Vec<Decorator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Decorator> {
-        <V as FoldAstPath>::fold_decorators(&mut **self, node, __ast_path)
+    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
+        <V as Fold>::fold_decorators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_default_decl(
-        &mut self,
-        node: DefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> DefaultDecl {
-        <V as FoldAstPath>::fold_default_decl(&mut **self, node, __ast_path)
+    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
+        <V as Fold>::fold_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_do_while_stmt(
-        &mut self,
-        node: DoWhileStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DoWhileStmt {
-        <V as FoldAstPath>::fold_do_while_stmt(&mut **self, node, __ast_path)
+    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
+        <V as Fold>::fold_do_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
-        <V as FoldAstPath>::fold_empty_stmt(&mut **self, node, __ast_path)
+    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
+        <V as Fold>::fold_empty_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
-        <V as FoldAstPath>::fold_es_version(&mut **self, node, __ast_path)
+    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
+        <V as Fold>::fold_es_version(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
-        <V as FoldAstPath>::fold_export_all(&mut **self, node, __ast_path)
+    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
+        <V as Fold>::fold_export_all(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
-        <V as FoldAstPath>::fold_export_decl(&mut **self, node, __ast_path)
+    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
+        <V as Fold>::fold_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_default_decl(
-        &mut self,
-        node: ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultDecl {
-        <V as FoldAstPath>::fold_export_default_decl(&mut **self, node, __ast_path)
+    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
+        <V as Fold>::fold_export_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_default_expr(
-        &mut self,
-        node: ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultExpr {
-        <V as FoldAstPath>::fold_export_default_expr(&mut **self, node, __ast_path)
+    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
+        <V as Fold>::fold_export_default_expr(&mut **self, node)
     }
 
     #[inline]
     fn fold_export_default_specifier(
         &mut self,
         node: ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportDefaultSpecifier {
-        <V as FoldAstPath>::fold_export_default_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_export_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_named_specifier(
-        &mut self,
-        node: ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportNamedSpecifier {
-        <V as FoldAstPath>::fold_export_named_specifier(&mut **self, node, __ast_path)
+    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
+        <V as Fold>::fold_export_named_specifier(&mut **self, node)
     }
 
     #[inline]
     fn fold_export_namespace_specifier(
         &mut self,
         node: ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportNamespaceSpecifier {
-        <V as FoldAstPath>::fold_export_namespace_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_export_namespace_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_specifier(
-        &mut self,
-        node: ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportSpecifier {
-        <V as FoldAstPath>::fold_export_specifier(&mut **self, node, __ast_path)
+    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
+        <V as Fold>::fold_export_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_specifiers(
-        &mut self,
-        node: Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExportSpecifier> {
-        <V as FoldAstPath>::fold_export_specifiers(&mut **self, node, __ast_path)
+    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
+        <V as Fold>::fold_export_specifiers(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
-        <V as FoldAstPath>::fold_expr(&mut **self, node, __ast_path)
+    fn fold_expr(&mut self, node: Expr) -> Expr {
+        <V as Fold>::fold_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr_or_spread(
-        &mut self,
-        node: ExprOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> ExprOrSpread {
-        <V as FoldAstPath>::fold_expr_or_spread(&mut **self, node, __ast_path)
+    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
+        <V as Fold>::fold_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr_or_spreads(
-        &mut self,
-        node: Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExprOrSpread> {
-        <V as FoldAstPath>::fold_expr_or_spreads(&mut **self, node, __ast_path)
+    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
+        <V as Fold>::fold_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
-        <V as FoldAstPath>::fold_expr_stmt(&mut **self, node, __ast_path)
+    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
+        <V as Fold>::fold_expr_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
-        <V as FoldAstPath>::fold_exprs(&mut **self, node, __ast_path)
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
+        <V as Fold>::fold_exprs(&mut **self, node)
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
-        <V as FoldAstPath>::fold_fn_decl(&mut **self, node, __ast_path)
+    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
+        <V as Fold>::fold_fn_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
-        <V as FoldAstPath>::fold_fn_expr(&mut **self, node, __ast_path)
+    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
+        <V as Fold>::fold_fn_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
-        <V as FoldAstPath>::fold_for_head(&mut **self, node, __ast_path)
+    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
+        <V as Fold>::fold_for_head(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
-        <V as FoldAstPath>::fold_for_in_stmt(&mut **self, node, __ast_path)
+    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
+        <V as Fold>::fold_for_in_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
-        <V as FoldAstPath>::fold_for_of_stmt(&mut **self, node, __ast_path)
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
+        <V as Fold>::fold_for_of_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
-        <V as FoldAstPath>::fold_for_stmt(&mut **self, node, __ast_path)
+    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
+        <V as Fold>::fold_for_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
-        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
+    fn fold_function(&mut self, node: Function) -> Function {
+        <V as Fold>::fold_function(&mut **self, node)
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
-        <V as FoldAstPath>::fold_getter_prop(&mut **self, node, __ast_path)
+    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
+        <V as Fold>::fold_getter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
-        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
+    fn fold_ident(&mut self, node: Ident) -> Ident {
+        <V as Fold>::fold_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
-        <V as FoldAstPath>::fold_ident_name(&mut **self, node, __ast_path)
+    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
+        <V as Fold>::fold_ident_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
-        <V as FoldAstPath>::fold_if_stmt(&mut **self, node, __ast_path)
+    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
+        <V as Fold>::fold_if_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
-        <V as FoldAstPath>::fold_import(&mut **self, node, __ast_path)
+    fn fold_import(&mut self, node: Import) -> Import {
+        <V as Fold>::fold_import(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
-        <V as FoldAstPath>::fold_import_decl(&mut **self, node, __ast_path)
+    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
+        <V as Fold>::fold_import_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_import_default_specifier(
         &mut self,
         node: ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportDefaultSpecifier {
-        <V as FoldAstPath>::fold_import_default_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_import_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_named_specifier(
-        &mut self,
-        node: ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportNamedSpecifier {
-        <V as FoldAstPath>::fold_import_named_specifier(&mut **self, node, __ast_path)
+    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
+        <V as Fold>::fold_import_named_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_phase(
-        &mut self,
-        node: ImportPhase,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPhase {
-        <V as FoldAstPath>::fold_import_phase(&mut **self, node, __ast_path)
+    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
+        <V as Fold>::fold_import_phase(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_specifier(
-        &mut self,
-        node: ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportSpecifier {
-        <V as FoldAstPath>::fold_import_specifier(&mut **self, node, __ast_path)
+    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
+        <V as Fold>::fold_import_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_specifiers(
-        &mut self,
-        node: Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportSpecifier> {
-        <V as FoldAstPath>::fold_import_specifiers(&mut **self, node, __ast_path)
+    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
+        <V as Fold>::fold_import_specifiers(&mut **self, node)
     }
 
     #[inline]
     fn fold_import_star_as_specifier(
         &mut self,
         node: ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportStarAsSpecifier {
-        <V as FoldAstPath>::fold_import_star_as_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_import_star_as_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
-        <V as FoldAstPath>::fold_import_with(&mut **self, node, __ast_path)
+    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
+        <V as Fold>::fold_import_with(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_with_item(
-        &mut self,
-        node: ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportWithItem {
-        <V as FoldAstPath>::fold_import_with_item(&mut **self, node, __ast_path)
+    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
+        <V as Fold>::fold_import_with_item(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_with_items(
-        &mut self,
-        node: Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportWithItem> {
-        <V as FoldAstPath>::fold_import_with_items(&mut **self, node, __ast_path)
+    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
+        <V as Fold>::fold_import_with_items(&mut **self, node)
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
-        <V as FoldAstPath>::fold_invalid(&mut **self, node, __ast_path)
+    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
+        <V as Fold>::fold_invalid(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
-        <V as FoldAstPath>::fold_jsx_attr(&mut **self, node, __ast_path)
+    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
+        <V as Fold>::fold_jsx_attr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_name(
-        &mut self,
-        node: JSXAttrName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrName {
-        <V as FoldAstPath>::fold_jsx_attr_name(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
+        <V as Fold>::fold_jsx_attr_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(
-        &mut self,
-        node: JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrOrSpread {
-        <V as FoldAstPath>::fold_jsx_attr_or_spread(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
+        <V as Fold>::fold_jsx_attr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(
-        &mut self,
-        node: Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXAttrOrSpread> {
-        <V as FoldAstPath>::fold_jsx_attr_or_spreads(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
+        <V as Fold>::fold_jsx_attr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_value(
-        &mut self,
-        node: JSXAttrValue,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrValue {
-        <V as FoldAstPath>::fold_jsx_attr_value(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
+        <V as Fold>::fold_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_closing_element(
-        &mut self,
-        node: JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingElement {
-        <V as FoldAstPath>::fold_jsx_closing_element(&mut **self, node, __ast_path)
+    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
+        <V as Fold>::fold_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(
-        &mut self,
-        node: JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingFragment {
-        <V as FoldAstPath>::fold_jsx_closing_fragment(&mut **self, node, __ast_path)
+    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
+        <V as Fold>::fold_jsx_closing_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
-        <V as FoldAstPath>::fold_jsx_element(&mut **self, node, __ast_path)
+    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
+        <V as Fold>::fold_jsx_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element_child(
-        &mut self,
-        node: JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementChild {
-        <V as FoldAstPath>::fold_jsx_element_child(&mut **self, node, __ast_path)
+    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
+        <V as Fold>::fold_jsx_element_child(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element_childs(
-        &mut self,
-        node: Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXElementChild> {
-        <V as FoldAstPath>::fold_jsx_element_childs(&mut **self, node, __ast_path)
+    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
+        <V as Fold>::fold_jsx_element_childs(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element_name(
-        &mut self,
-        node: JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementName {
-        <V as FoldAstPath>::fold_jsx_element_name(&mut **self, node, __ast_path)
+    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
+        <V as Fold>::fold_jsx_element_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(
-        &mut self,
-        node: JSXEmptyExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXEmptyExpr {
-        <V as FoldAstPath>::fold_jsx_empty_expr(&mut **self, node, __ast_path)
+    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
+        <V as Fold>::fold_jsx_empty_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
-        <V as FoldAstPath>::fold_jsx_expr(&mut **self, node, __ast_path)
+    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
+        <V as Fold>::fold_jsx_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_expr_container(
-        &mut self,
-        node: JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXExprContainer {
-        <V as FoldAstPath>::fold_jsx_expr_container(&mut **self, node, __ast_path)
+    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
+        <V as Fold>::fold_jsx_expr_container(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_fragment(
-        &mut self,
-        node: JSXFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXFragment {
-        <V as FoldAstPath>::fold_jsx_fragment(&mut **self, node, __ast_path)
+    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
+        <V as Fold>::fold_jsx_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_member_expr(
-        &mut self,
-        node: JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXMemberExpr {
-        <V as FoldAstPath>::fold_jsx_member_expr(&mut **self, node, __ast_path)
+    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
+        <V as Fold>::fold_jsx_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(
-        &mut self,
-        node: JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXNamespacedName {
-        <V as FoldAstPath>::fold_jsx_namespaced_name(&mut **self, node, __ast_path)
+    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
+        <V as Fold>::fold_jsx_namespaced_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
-        <V as FoldAstPath>::fold_jsx_object(&mut **self, node, __ast_path)
+    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
+        <V as Fold>::fold_jsx_object(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_opening_element(
-        &mut self,
-        node: JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningElement {
-        <V as FoldAstPath>::fold_jsx_opening_element(&mut **self, node, __ast_path)
+    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
+        <V as Fold>::fold_jsx_opening_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(
-        &mut self,
-        node: JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningFragment {
-        <V as FoldAstPath>::fold_jsx_opening_fragment(&mut **self, node, __ast_path)
+    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
+        <V as Fold>::fold_jsx_opening_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_spread_child(
-        &mut self,
-        node: JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXSpreadChild {
-        <V as FoldAstPath>::fold_jsx_spread_child(&mut **self, node, __ast_path)
+    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
+        <V as Fold>::fold_jsx_spread_child(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
-        <V as FoldAstPath>::fold_jsx_text(&mut **self, node, __ast_path)
+    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
+        <V as Fold>::fold_jsx_text(&mut **self, node)
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
-        <V as FoldAstPath>::fold_key(&mut **self, node, __ast_path)
+    fn fold_key(&mut self, node: Key) -> Key {
+        <V as Fold>::fold_key(&mut **self, node)
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(
-        &mut self,
-        node: KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValuePatProp {
-        <V as FoldAstPath>::fold_key_value_pat_prop(&mut **self, node, __ast_path)
+    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
+        <V as Fold>::fold_key_value_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_key_value_prop(
-        &mut self,
-        node: KeyValueProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValueProp {
-        <V as FoldAstPath>::fold_key_value_prop(&mut **self, node, __ast_path)
+    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
+        <V as Fold>::fold_key_value_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_labeled_stmt(
-        &mut self,
-        node: LabeledStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> LabeledStmt {
-        <V as FoldAstPath>::fold_labeled_stmt(&mut **self, node, __ast_path)
+    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
+        <V as Fold>::fold_labeled_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
-        <V as FoldAstPath>::fold_lit(&mut **self, node, __ast_path)
+    fn fold_lit(&mut self, node: Lit) -> Lit {
+        <V as Fold>::fold_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
-        <V as FoldAstPath>::fold_member_expr(&mut **self, node, __ast_path)
+    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
+        <V as Fold>::fold_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
-        <V as FoldAstPath>::fold_member_prop(&mut **self, node, __ast_path)
+    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
+        <V as Fold>::fold_member_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_meta_prop_expr(
-        &mut self,
-        node: MetaPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropExpr {
-        <V as FoldAstPath>::fold_meta_prop_expr(&mut **self, node, __ast_path)
+    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
+        <V as Fold>::fold_meta_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_meta_prop_kind(
-        &mut self,
-        node: MetaPropKind,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropKind {
-        <V as FoldAstPath>::fold_meta_prop_kind(&mut **self, node, __ast_path)
+    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
+        <V as Fold>::fold_meta_prop_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
-        <V as FoldAstPath>::fold_method_kind(&mut **self, node, __ast_path)
+    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
+        <V as Fold>::fold_method_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
-        <V as FoldAstPath>::fold_method_prop(&mut **self, node, __ast_path)
+    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
+        <V as Fold>::fold_method_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
-        <V as FoldAstPath>::fold_module(&mut **self, node, __ast_path)
+    fn fold_module(&mut self, node: Module) -> Module {
+        <V as Fold>::fold_module(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
-        <V as FoldAstPath>::fold_module_decl(&mut **self, node, __ast_path)
+    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
+        <V as Fold>::fold_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_export_name(
-        &mut self,
-        node: ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) -> ModuleExportName {
-        <V as FoldAstPath>::fold_module_export_name(&mut **self, node, __ast_path)
+    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
+        <V as Fold>::fold_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
-        <V as FoldAstPath>::fold_module_item(&mut **self, node, __ast_path)
+    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
+        <V as Fold>::fold_module_item(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_items(
-        &mut self,
-        node: Vec<ModuleItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ModuleItem> {
-        <V as FoldAstPath>::fold_module_items(&mut **self, node, __ast_path)
+    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
+        <V as Fold>::fold_module_items(&mut **self, node)
     }
 
     #[inline]
-    fn fold_named_export(
-        &mut self,
-        node: NamedExport,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedExport {
-        <V as FoldAstPath>::fold_named_export(&mut **self, node, __ast_path)
+    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
+        <V as Fold>::fold_named_export(&mut **self, node)
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
-        <V as FoldAstPath>::fold_new_expr(&mut **self, node, __ast_path)
+    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
+        <V as Fold>::fold_new_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
-        <V as FoldAstPath>::fold_null(&mut **self, node, __ast_path)
+    fn fold_null(&mut self, node: Null) -> Null {
+        <V as Fold>::fold_null(&mut **self, node)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
-        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
+    fn fold_number(&mut self, node: Number) -> Number {
+        <V as Fold>::fold_number(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
-        <V as FoldAstPath>::fold_object_lit(&mut **self, node, __ast_path)
+    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
+        <V as Fold>::fold_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
-        <V as FoldAstPath>::fold_object_pat(&mut **self, node, __ast_path)
+    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
+        <V as Fold>::fold_object_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_pat_prop(
-        &mut self,
-        node: ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ObjectPatProp {
-        <V as FoldAstPath>::fold_object_pat_prop(&mut **self, node, __ast_path)
+    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
+        <V as Fold>::fold_object_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_pat_props(
-        &mut self,
-        node: Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ObjectPatProp> {
-        <V as FoldAstPath>::fold_object_pat_props(&mut **self, node, __ast_path)
+    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
+        <V as Fold>::fold_object_pat_props(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_accessibility(
-        &mut self,
-        node: Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Accessibility> {
-        <V as FoldAstPath>::fold_opt_accessibility(&mut **self, node, __ast_path)
+    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
+        <V as Fold>::fold_opt_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
-        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+        <V as Fold>::fold_opt_atom(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_block_stmt(
-        &mut self,
-        node: Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<BlockStmt> {
-        <V as FoldAstPath>::fold_opt_block_stmt(&mut **self, node, __ast_path)
+    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
+        <V as Fold>::fold_opt_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
-        <V as FoldAstPath>::fold_opt_call(&mut **self, node, __ast_path)
+    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
+        <V as Fold>::fold_opt_call(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_catch_clause(
-        &mut self,
-        node: Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<CatchClause> {
-        <V as FoldAstPath>::fold_opt_catch_clause(&mut **self, node, __ast_path)
+    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
+        <V as Fold>::fold_opt_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_chain_base(
-        &mut self,
-        node: OptChainBase,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainBase {
-        <V as FoldAstPath>::fold_opt_chain_base(&mut **self, node, __ast_path)
+    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
+        <V as Fold>::fold_opt_chain_base(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_chain_expr(
-        &mut self,
-        node: OptChainExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainExpr {
-        <V as FoldAstPath>::fold_opt_chain_expr(&mut **self, node, __ast_path)
+    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
+        <V as Fold>::fold_opt_chain_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_expr(
-        &mut self,
-        node: Option<Box<Expr>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Expr>> {
-        <V as FoldAstPath>::fold_opt_expr(&mut **self, node, __ast_path)
+    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
+        <V as Fold>::fold_opt_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(
-        &mut self,
-        node: Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ExprOrSpread> {
-        <V as FoldAstPath>::fold_opt_expr_or_spread(&mut **self, node, __ast_path)
+    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
+        <V as Fold>::fold_opt_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_expr_or_spreads(
         &mut self,
         node: Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<ExprOrSpread>> {
-        <V as FoldAstPath>::fold_opt_expr_or_spreads(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
-        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+        <V as Fold>::fold_opt_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(
-        &mut self,
-        node: Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<JSXAttrValue> {
-        <V as FoldAstPath>::fold_opt_jsx_attr_value(&mut **self, node, __ast_path)
+    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
+        <V as Fold>::fold_opt_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_jsx_closing_element(
         &mut self,
         node: Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<JSXClosingElement> {
-        <V as FoldAstPath>::fold_opt_jsx_closing_element(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_module_export_name(
         &mut self,
         node: Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ModuleExportName> {
-        <V as FoldAstPath>::fold_opt_module_export_name(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_object_lit(
-        &mut self,
-        node: Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<ObjectLit>> {
-        <V as FoldAstPath>::fold_opt_object_lit(&mut **self, node, __ast_path)
+    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
+        <V as Fold>::fold_opt_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
-        <V as FoldAstPath>::fold_opt_pat(&mut **self, node, __ast_path)
+    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
+        <V as Fold>::fold_opt_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_span(
-        &mut self,
-        node: Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_common::Span> {
-        <V as FoldAstPath>::fold_opt_span(&mut **self, node, __ast_path)
+    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
+        <V as Fold>::fold_opt_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_stmt(
-        &mut self,
-        node: Option<Box<Stmt>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Stmt>> {
-        <V as FoldAstPath>::fold_opt_stmt(&mut **self, node, __ast_path)
+    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
+        <V as Fold>::fold_opt_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_str(
-        &mut self,
-        node: Option<Box<Str>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Str>> {
-        <V as FoldAstPath>::fold_opt_str(&mut **self, node, __ast_path)
+    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
+        <V as Fold>::fold_opt_str(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(
-        &mut self,
-        node: Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TruePlusMinus> {
-        <V as FoldAstPath>::fold_opt_true_plus_minus(&mut **self, node, __ast_path)
+    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
+        <V as Fold>::fold_opt_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(
-        &mut self,
-        node: Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TsEntityName> {
-        <V as FoldAstPath>::fold_opt_ts_entity_name(&mut **self, node, __ast_path)
+    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
+        <V as Fold>::fold_opt_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_ts_namespace_body(
         &mut self,
         node: Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<TsNamespaceBody> {
-        <V as FoldAstPath>::fold_opt_ts_namespace_body(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ts_type(
-        &mut self,
-        node: Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsType>> {
-        <V as FoldAstPath>::fold_opt_ts_type(&mut **self, node, __ast_path)
+    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
+        <V as Fold>::fold_opt_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(
-        &mut self,
-        node: Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsTypeAnn>> {
-        <V as FoldAstPath>::fold_opt_ts_type_ann(&mut **self, node, __ast_path)
+    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
+        <V as Fold>::fold_opt_ts_type_ann(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_ts_type_param_decl(
         &mut self,
         node: Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamDecl>> {
-        <V as FoldAstPath>::fold_opt_ts_type_param_decl(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_ts_type_param_instantiation(
         &mut self,
         node: Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamInstantiation>> {
-        <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(
-        &mut self,
-        node: Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<VarDeclOrExpr> {
-        <V as FoldAstPath>::fold_opt_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
+        <V as Fold>::fold_opt_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_vec_expr_or_spreads(
         &mut self,
         node: Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<Option<ExprOrSpread>> {
-        <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_vec_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_vec_pats(
-        &mut self,
-        node: Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Option<Pat>> {
-        <V as FoldAstPath>::fold_opt_vec_pats(&mut **self, node, __ast_path)
+    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
+        <V as Fold>::fold_opt_vec_pats(&mut **self, node)
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
-        <V as FoldAstPath>::fold_param(&mut **self, node, __ast_path)
+    fn fold_param(&mut self, node: Param) -> Param {
+        <V as Fold>::fold_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(
-        &mut self,
-        node: ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ParamOrTsParamProp {
-        <V as FoldAstPath>::fold_param_or_ts_param_prop(&mut **self, node, __ast_path)
+    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
+        <V as Fold>::fold_param_or_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
     fn fold_param_or_ts_param_props(
         &mut self,
         node: Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ParamOrTsParamProp> {
-        <V as FoldAstPath>::fold_param_or_ts_param_props(&mut **self, node, __ast_path)
+        <V as Fold>::fold_param_or_ts_param_props(&mut **self, node)
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
-        <V as FoldAstPath>::fold_params(&mut **self, node, __ast_path)
+    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
+        <V as Fold>::fold_params(&mut **self, node)
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
-        <V as FoldAstPath>::fold_paren_expr(&mut **self, node, __ast_path)
+    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
+        <V as Fold>::fold_paren_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
-        <V as FoldAstPath>::fold_pat(&mut **self, node, __ast_path)
+    fn fold_pat(&mut self, node: Pat) -> Pat {
+        <V as Fold>::fold_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
-        <V as FoldAstPath>::fold_pats(&mut **self, node, __ast_path)
+    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
+        <V as Fold>::fold_pats(&mut **self, node)
     }
 
     #[inline]
-    fn fold_private_method(
-        &mut self,
-        node: PrivateMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateMethod {
-        <V as FoldAstPath>::fold_private_method(&mut **self, node, __ast_path)
+    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
+        <V as Fold>::fold_private_method(&mut **self, node)
     }
 
     #[inline]
-    fn fold_private_name(
-        &mut self,
-        node: PrivateName,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateName {
-        <V as FoldAstPath>::fold_private_name(&mut **self, node, __ast_path)
+    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
+        <V as Fold>::fold_private_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_private_prop(
-        &mut self,
-        node: PrivateProp,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateProp {
-        <V as FoldAstPath>::fold_private_prop(&mut **self, node, __ast_path)
+    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
+        <V as Fold>::fold_private_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
-        <V as FoldAstPath>::fold_program(&mut **self, node, __ast_path)
+    fn fold_program(&mut self, node: Program) -> Program {
+        <V as Fold>::fold_program(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
-        <V as FoldAstPath>::fold_prop(&mut **self, node, __ast_path)
+    fn fold_prop(&mut self, node: Prop) -> Prop {
+        <V as Fold>::fold_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
-        <V as FoldAstPath>::fold_prop_name(&mut **self, node, __ast_path)
+    fn fold_prop_name(&mut self, node: PropName) -> PropName {
+        <V as Fold>::fold_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop_or_spread(
-        &mut self,
-        node: PropOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> PropOrSpread {
-        <V as FoldAstPath>::fold_prop_or_spread(&mut **self, node, __ast_path)
+    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
+        <V as Fold>::fold_prop_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop_or_spreads(
-        &mut self,
-        node: Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PropOrSpread> {
-        <V as FoldAstPath>::fold_prop_or_spreads(&mut **self, node, __ast_path)
+    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
+        <V as Fold>::fold_prop_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
-        <V as FoldAstPath>::fold_regex(&mut **self, node, __ast_path)
+    fn fold_regex(&mut self, node: Regex) -> Regex {
+        <V as Fold>::fold_regex(&mut **self, node)
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
-        <V as FoldAstPath>::fold_rest_pat(&mut **self, node, __ast_path)
+    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
+        <V as Fold>::fold_rest_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
-        <V as FoldAstPath>::fold_return_stmt(&mut **self, node, __ast_path)
+    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
+        <V as Fold>::fold_return_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
-        <V as FoldAstPath>::fold_script(&mut **self, node, __ast_path)
+    fn fold_script(&mut self, node: Script) -> Script {
+        <V as Fold>::fold_script(&mut **self, node)
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
-        <V as FoldAstPath>::fold_seq_expr(&mut **self, node, __ast_path)
+    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
+        <V as Fold>::fold_seq_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
-        <V as FoldAstPath>::fold_setter_prop(&mut **self, node, __ast_path)
+    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
+        <V as Fold>::fold_setter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_simple_assign_target(
-        &mut self,
-        node: SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleAssignTarget {
-        <V as FoldAstPath>::fold_simple_assign_target(&mut **self, node, __ast_path)
+    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
+        <V as Fold>::fold_simple_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
-        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+        <V as Fold>::fold_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_spread_element(
-        &mut self,
-        node: SpreadElement,
-        __ast_path: &mut AstKindPath,
-    ) -> SpreadElement {
-        <V as FoldAstPath>::fold_spread_element(&mut **self, node, __ast_path)
+    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
+        <V as Fold>::fold_spread_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_static_block(
-        &mut self,
-        node: StaticBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> StaticBlock {
-        <V as FoldAstPath>::fold_static_block(&mut **self, node, __ast_path)
+    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
+        <V as Fold>::fold_static_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
-        <V as FoldAstPath>::fold_stmt(&mut **self, node, __ast_path)
+    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
+        <V as Fold>::fold_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
-        <V as FoldAstPath>::fold_stmts(&mut **self, node, __ast_path)
+    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
+        <V as Fold>::fold_stmts(&mut **self, node)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
-        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
+    fn fold_str(&mut self, node: Str) -> Str {
+        <V as Fold>::fold_str(&mut **self, node)
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
-        <V as FoldAstPath>::fold_super(&mut **self, node, __ast_path)
+    fn fold_super(&mut self, node: Super) -> Super {
+        <V as Fold>::fold_super(&mut **self, node)
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
-        <V as FoldAstPath>::fold_super_prop(&mut **self, node, __ast_path)
+    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
+        <V as Fold>::fold_super_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_super_prop_expr(
-        &mut self,
-        node: SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> SuperPropExpr {
-        <V as FoldAstPath>::fold_super_prop_expr(&mut **self, node, __ast_path)
+    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
+        <V as Fold>::fold_super_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
-        <V as FoldAstPath>::fold_switch_case(&mut **self, node, __ast_path)
+    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
+        <V as Fold>::fold_switch_case(&mut **self, node)
     }
 
     #[inline]
-    fn fold_switch_cases(
-        &mut self,
-        node: Vec<SwitchCase>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SwitchCase> {
-        <V as FoldAstPath>::fold_switch_cases(&mut **self, node, __ast_path)
+    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
+        <V as Fold>::fold_switch_cases(&mut **self, node)
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
-        <V as FoldAstPath>::fold_switch_stmt(&mut **self, node, __ast_path)
+    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
+        <V as Fold>::fold_switch_stmt(&mut **self, node)
     }
 
     #[inline]
     fn fold_syntax_context(
         &mut self,
         node: swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
     ) -> swc_common::SyntaxContext {
-        <V as FoldAstPath>::fold_syntax_context(&mut **self, node, __ast_path)
+        <V as Fold>::fold_syntax_context(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
-        <V as FoldAstPath>::fold_tagged_tpl(&mut **self, node, __ast_path)
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
+        <V as Fold>::fold_tagged_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
-        <V as FoldAstPath>::fold_this_expr(&mut **self, node, __ast_path)
+    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
+        <V as Fold>::fold_this_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
-        <V as FoldAstPath>::fold_throw_stmt(&mut **self, node, __ast_path)
+    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
+        <V as Fold>::fold_throw_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
-        <V as FoldAstPath>::fold_tpl(&mut **self, node, __ast_path)
+    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
+        <V as Fold>::fold_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
-        <V as FoldAstPath>::fold_tpl_element(&mut **self, node, __ast_path)
+    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
+        <V as Fold>::fold_tpl_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tpl_elements(
-        &mut self,
-        node: Vec<TplElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TplElement> {
-        <V as FoldAstPath>::fold_tpl_elements(&mut **self, node, __ast_path)
+    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
+        <V as Fold>::fold_tpl_elements(&mut **self, node)
     }
 
     #[inline]
-    fn fold_true_plus_minus(
-        &mut self,
-        node: TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) -> TruePlusMinus {
-        <V as FoldAstPath>::fold_true_plus_minus(&mut **self, node, __ast_path)
+    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
+        <V as Fold>::fold_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
-        <V as FoldAstPath>::fold_try_stmt(&mut **self, node, __ast_path)
+    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
+        <V as Fold>::fold_try_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_array_type(
-        &mut self,
-        node: TsArrayType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsArrayType {
-        <V as FoldAstPath>::fold_ts_array_type(&mut **self, node, __ast_path)
+    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
+        <V as Fold>::fold_ts_array_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
-        <V as FoldAstPath>::fold_ts_as_expr(&mut **self, node, __ast_path)
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
+        <V as Fold>::fold_ts_as_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(
-        &mut self,
-        node: TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsCallSignatureDecl {
-        <V as FoldAstPath>::fold_ts_call_signature_decl(&mut **self, node, __ast_path)
+    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
+        <V as Fold>::fold_ts_call_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_conditional_type(
-        &mut self,
-        node: TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConditionalType {
-        <V as FoldAstPath>::fold_ts_conditional_type(&mut **self, node, __ast_path)
+    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
+        <V as Fold>::fold_ts_conditional_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_const_assertion(
-        &mut self,
-        node: TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstAssertion {
-        <V as FoldAstPath>::fold_ts_const_assertion(&mut **self, node, __ast_path)
+    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
+        <V as Fold>::fold_ts_const_assertion(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_construct_signature_decl(
         &mut self,
         node: TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsConstructSignatureDecl {
-        <V as FoldAstPath>::fold_ts_construct_signature_decl(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_construct_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_constructor_type(
-        &mut self,
-        node: TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstructorType {
-        <V as FoldAstPath>::fold_ts_constructor_type(&mut **self, node, __ast_path)
+    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
+        <V as Fold>::fold_ts_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_entity_name(
-        &mut self,
-        node: TsEntityName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEntityName {
-        <V as FoldAstPath>::fold_ts_entity_name(&mut **self, node, __ast_path)
+    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
+        <V as Fold>::fold_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
-        <V as FoldAstPath>::fold_ts_enum_decl(&mut **self, node, __ast_path)
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
+        <V as Fold>::fold_ts_enum_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_member(
-        &mut self,
-        node: TsEnumMember,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMember {
-        <V as FoldAstPath>::fold_ts_enum_member(&mut **self, node, __ast_path)
+    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
+        <V as Fold>::fold_ts_enum_member(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(
-        &mut self,
-        node: TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMemberId {
-        <V as FoldAstPath>::fold_ts_enum_member_id(&mut **self, node, __ast_path)
+    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
+        <V as Fold>::fold_ts_enum_member_id(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_members(
-        &mut self,
-        node: Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsEnumMember> {
-        <V as FoldAstPath>::fold_ts_enum_members(&mut **self, node, __ast_path)
+    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
+        <V as Fold>::fold_ts_enum_members(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_export_assignment(
-        &mut self,
-        node: TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExportAssignment {
-        <V as FoldAstPath>::fold_ts_export_assignment(&mut **self, node, __ast_path)
+    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
+        <V as Fold>::fold_ts_export_assignment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(
-        &mut self,
-        node: TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExprWithTypeArgs {
-        <V as FoldAstPath>::fold_ts_expr_with_type_args(&mut **self, node, __ast_path)
+    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
+        <V as Fold>::fold_ts_expr_with_type_args(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_expr_with_type_argss(
         &mut self,
         node: Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<TsExprWithTypeArgs> {
-        <V as FoldAstPath>::fold_ts_expr_with_type_argss(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_expr_with_type_argss(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(
-        &mut self,
-        node: TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExternalModuleRef {
-        <V as FoldAstPath>::fold_ts_external_module_ref(&mut **self, node, __ast_path)
+    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
+        <V as Fold>::fold_ts_external_module_ref(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_fn_or_constructor_type(
         &mut self,
         node: TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
     ) -> TsFnOrConstructorType {
-        <V as FoldAstPath>::fold_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_fn_or_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
-        <V as FoldAstPath>::fold_ts_fn_param(&mut **self, node, __ast_path)
+    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
+        <V as Fold>::fold_ts_fn_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_fn_params(
-        &mut self,
-        node: Vec<TsFnParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsFnParam> {
-        <V as FoldAstPath>::fold_ts_fn_params(&mut **self, node, __ast_path)
+    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
+        <V as Fold>::fold_ts_fn_params(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
-        <V as FoldAstPath>::fold_ts_fn_type(&mut **self, node, __ast_path)
+    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
+        <V as Fold>::fold_ts_fn_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_getter_signature(
-        &mut self,
-        node: TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsGetterSignature {
-        <V as FoldAstPath>::fold_ts_getter_signature(&mut **self, node, __ast_path)
+    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
+        <V as Fold>::fold_ts_getter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(
-        &mut self,
-        node: TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportEqualsDecl {
-        <V as FoldAstPath>::fold_ts_import_equals_decl(&mut **self, node, __ast_path)
+    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
+        <V as Fold>::fold_ts_import_equals_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_import_type(
-        &mut self,
-        node: TsImportType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportType {
-        <V as FoldAstPath>::fold_ts_import_type(&mut **self, node, __ast_path)
+    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
+        <V as Fold>::fold_ts_import_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_index_signature(
-        &mut self,
-        node: TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexSignature {
-        <V as FoldAstPath>::fold_ts_index_signature(&mut **self, node, __ast_path)
+    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
+        <V as Fold>::fold_ts_index_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(
-        &mut self,
-        node: TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexedAccessType {
-        <V as FoldAstPath>::fold_ts_indexed_access_type(&mut **self, node, __ast_path)
+    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
+        <V as Fold>::fold_ts_indexed_access_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_infer_type(
-        &mut self,
-        node: TsInferType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInferType {
-        <V as FoldAstPath>::fold_ts_infer_type(&mut **self, node, __ast_path)
+    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
+        <V as Fold>::fold_ts_infer_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_instantiation(
-        &mut self,
-        node: TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInstantiation {
-        <V as FoldAstPath>::fold_ts_instantiation(&mut **self, node, __ast_path)
+    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
+        <V as Fold>::fold_ts_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_interface_body(
-        &mut self,
-        node: TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceBody {
-        <V as FoldAstPath>::fold_ts_interface_body(&mut **self, node, __ast_path)
+    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
+        <V as Fold>::fold_ts_interface_body(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_interface_decl(
-        &mut self,
-        node: TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceDecl {
-        <V as FoldAstPath>::fold_ts_interface_decl(&mut **self, node, __ast_path)
+    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
+        <V as Fold>::fold_ts_interface_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_intersection_type(
-        &mut self,
-        node: TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIntersectionType {
-        <V as FoldAstPath>::fold_ts_intersection_type(&mut **self, node, __ast_path)
+    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
+        <V as Fold>::fold_ts_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_keyword_type(
-        &mut self,
-        node: TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordType {
-        <V as FoldAstPath>::fold_ts_keyword_type(&mut **self, node, __ast_path)
+    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
+        <V as Fold>::fold_ts_keyword_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(
-        &mut self,
-        node: TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordTypeKind {
-        <V as FoldAstPath>::fold_ts_keyword_type_kind(&mut **self, node, __ast_path)
+    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
+        <V as Fold>::fold_ts_keyword_type_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
-        <V as FoldAstPath>::fold_ts_lit(&mut **self, node, __ast_path)
+    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
+        <V as Fold>::fold_ts_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
-        <V as FoldAstPath>::fold_ts_lit_type(&mut **self, node, __ast_path)
+    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
+        <V as Fold>::fold_ts_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_mapped_type(
-        &mut self,
-        node: TsMappedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMappedType {
-        <V as FoldAstPath>::fold_ts_mapped_type(&mut **self, node, __ast_path)
+    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
+        <V as Fold>::fold_ts_mapped_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_method_signature(
-        &mut self,
-        node: TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMethodSignature {
-        <V as FoldAstPath>::fold_ts_method_signature(&mut **self, node, __ast_path)
+    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
+        <V as Fold>::fold_ts_method_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_block(
-        &mut self,
-        node: TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleBlock {
-        <V as FoldAstPath>::fold_ts_module_block(&mut **self, node, __ast_path)
+    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
+        <V as Fold>::fold_ts_module_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_decl(
-        &mut self,
-        node: TsModuleDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleDecl {
-        <V as FoldAstPath>::fold_ts_module_decl(&mut **self, node, __ast_path)
+    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
+        <V as Fold>::fold_ts_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_name(
-        &mut self,
-        node: TsModuleName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleName {
-        <V as FoldAstPath>::fold_ts_module_name(&mut **self, node, __ast_path)
+    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
+        <V as Fold>::fold_ts_module_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_ref(
-        &mut self,
-        node: TsModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleRef {
-        <V as FoldAstPath>::fold_ts_module_ref(&mut **self, node, __ast_path)
+    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
+        <V as Fold>::fold_ts_module_ref(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_namespace_body(
-        &mut self,
-        node: TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceBody {
-        <V as FoldAstPath>::fold_ts_namespace_body(&mut **self, node, __ast_path)
+    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
+        <V as Fold>::fold_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(
-        &mut self,
-        node: TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceDecl {
-        <V as FoldAstPath>::fold_ts_namespace_decl(&mut **self, node, __ast_path)
+    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
+        <V as Fold>::fold_ts_namespace_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_namespace_export_decl(
         &mut self,
         node: TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsNamespaceExportDecl {
-        <V as FoldAstPath>::fold_ts_namespace_export_decl(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_namespace_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(
-        &mut self,
-        node: TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNonNullExpr {
-        <V as FoldAstPath>::fold_ts_non_null_expr(&mut **self, node, __ast_path)
+    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
+        <V as Fold>::fold_ts_non_null_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_optional_type(
-        &mut self,
-        node: TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsOptionalType {
-        <V as FoldAstPath>::fold_ts_optional_type(&mut **self, node, __ast_path)
+    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
+        <V as Fold>::fold_ts_optional_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_param_prop(
-        &mut self,
-        node: TsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamProp {
-        <V as FoldAstPath>::fold_ts_param_prop(&mut **self, node, __ast_path)
+    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
+        <V as Fold>::fold_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(
-        &mut self,
-        node: TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamPropParam {
-        <V as FoldAstPath>::fold_ts_param_prop_param(&mut **self, node, __ast_path)
+    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
+        <V as Fold>::fold_ts_param_prop_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(
-        &mut self,
-        node: TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParenthesizedType {
-        <V as FoldAstPath>::fold_ts_parenthesized_type(&mut **self, node, __ast_path)
+    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
+        <V as Fold>::fold_ts_parenthesized_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_property_signature(
-        &mut self,
-        node: TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsPropertySignature {
-        <V as FoldAstPath>::fold_ts_property_signature(&mut **self, node, __ast_path)
+    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
+        <V as Fold>::fold_ts_property_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_qualified_name(
-        &mut self,
-        node: TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsQualifiedName {
-        <V as FoldAstPath>::fold_ts_qualified_name(&mut **self, node, __ast_path)
+    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
+        <V as Fold>::fold_ts_qualified_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
-        <V as FoldAstPath>::fold_ts_rest_type(&mut **self, node, __ast_path)
+    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
+        <V as Fold>::fold_ts_rest_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(
-        &mut self,
-        node: TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSatisfiesExpr {
-        <V as FoldAstPath>::fold_ts_satisfies_expr(&mut **self, node, __ast_path)
+    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
+        <V as Fold>::fold_ts_satisfies_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_setter_signature(
-        &mut self,
-        node: TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSetterSignature {
-        <V as FoldAstPath>::fold_ts_setter_signature(&mut **self, node, __ast_path)
+    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
+        <V as Fold>::fold_ts_setter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
-        <V as FoldAstPath>::fold_ts_this_type(&mut **self, node, __ast_path)
+    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
+        <V as Fold>::fold_ts_this_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(
-        &mut self,
-        node: TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> TsThisTypeOrIdent {
-        <V as FoldAstPath>::fold_ts_this_type_or_ident(&mut **self, node, __ast_path)
+    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
+        <V as Fold>::fold_ts_this_type_or_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(
-        &mut self,
-        node: TsTplLitType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTplLitType {
-        <V as FoldAstPath>::fold_ts_tpl_lit_type(&mut **self, node, __ast_path)
+    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
+        <V as Fold>::fold_ts_tpl_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tuple_element(
-        &mut self,
-        node: TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleElement {
-        <V as FoldAstPath>::fold_ts_tuple_element(&mut **self, node, __ast_path)
+    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
+        <V as Fold>::fold_ts_tuple_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(
-        &mut self,
-        node: Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTupleElement> {
-        <V as FoldAstPath>::fold_ts_tuple_elements(&mut **self, node, __ast_path)
+    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
+        <V as Fold>::fold_ts_tuple_elements(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tuple_type(
-        &mut self,
-        node: TsTupleType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleType {
-        <V as FoldAstPath>::fold_ts_tuple_type(&mut **self, node, __ast_path)
+    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
+        <V as Fold>::fold_ts_tuple_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
-        <V as FoldAstPath>::fold_ts_type(&mut **self, node, __ast_path)
+    fn fold_ts_type(&mut self, node: TsType) -> TsType {
+        <V as Fold>::fold_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(
-        &mut self,
-        node: TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAliasDecl {
-        <V as FoldAstPath>::fold_ts_type_alias_decl(&mut **self, node, __ast_path)
+    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
+        <V as Fold>::fold_ts_type_alias_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
-        <V as FoldAstPath>::fold_ts_type_ann(&mut **self, node, __ast_path)
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
+        <V as Fold>::fold_ts_type_ann(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_assertion(
-        &mut self,
-        node: TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAssertion {
-        <V as FoldAstPath>::fold_ts_type_assertion(&mut **self, node, __ast_path)
+    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
+        <V as Fold>::fold_ts_type_assertion(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_element(
-        &mut self,
-        node: TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeElement {
-        <V as FoldAstPath>::fold_ts_type_element(&mut **self, node, __ast_path)
+    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
+        <V as Fold>::fold_ts_type_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_elements(
-        &mut self,
-        node: Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeElement> {
-        <V as FoldAstPath>::fold_ts_type_elements(&mut **self, node, __ast_path)
+    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
+        <V as Fold>::fold_ts_type_elements(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
-        <V as FoldAstPath>::fold_ts_type_lit(&mut **self, node, __ast_path)
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
+        <V as Fold>::fold_ts_type_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_operator(
-        &mut self,
-        node: TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperator {
-        <V as FoldAstPath>::fold_ts_type_operator(&mut **self, node, __ast_path)
+    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
+        <V as Fold>::fold_ts_type_operator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(
-        &mut self,
-        node: TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperatorOp {
-        <V as FoldAstPath>::fold_ts_type_operator_op(&mut **self, node, __ast_path)
+    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
+        <V as Fold>::fold_ts_type_operator_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_param(
-        &mut self,
-        node: TsTypeParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParam {
-        <V as FoldAstPath>::fold_ts_type_param(&mut **self, node, __ast_path)
+    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
+        <V as Fold>::fold_ts_type_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(
-        &mut self,
-        node: TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParamDecl {
-        <V as FoldAstPath>::fold_ts_type_param_decl(&mut **self, node, __ast_path)
+    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
+        <V as Fold>::fold_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_type_param_instantiation(
         &mut self,
         node: TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
     ) -> TsTypeParamInstantiation {
-        <V as FoldAstPath>::fold_ts_type_param_instantiation(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_params(
-        &mut self,
-        node: Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeParam> {
-        <V as FoldAstPath>::fold_ts_type_params(&mut **self, node, __ast_path)
+    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
+        <V as Fold>::fold_ts_type_params(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_predicate(
-        &mut self,
-        node: TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypePredicate {
-        <V as FoldAstPath>::fold_ts_type_predicate(&mut **self, node, __ast_path)
+    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
+        <V as Fold>::fold_ts_type_predicate(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_query(
-        &mut self,
-        node: TsTypeQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQuery {
-        <V as FoldAstPath>::fold_ts_type_query(&mut **self, node, __ast_path)
+    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
+        <V as Fold>::fold_ts_type_query(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(
-        &mut self,
-        node: TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQueryExpr {
-        <V as FoldAstPath>::fold_ts_type_query_expr(&mut **self, node, __ast_path)
+    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
+        <V as Fold>::fold_ts_type_query_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
-        <V as FoldAstPath>::fold_ts_type_ref(&mut **self, node, __ast_path)
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
+        <V as Fold>::fold_ts_type_ref(&mut **self, node)
     }
-
-    #[inline]
-    fn fold_ts_types(
-        &mut self,
-        node: Vec<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Box<TsType>> {
-        <V as FoldAstPath>::fold_ts_types(&mut **self, node, __ast_path)
+
+    #[inline]
+    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
+        <V as Fold>::fold_ts_types(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_union_or_intersection_type(
         &mut self,
         node: TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
     ) -> TsUnionOrIntersectionType {
-        <V as FoldAstPath>::fold_ts_union_or_intersection_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_union_or_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_union_type(
-        &mut self,
-        node: TsUnionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsUnionType {
-        <V as FoldAstPath>::fold_ts_union_type(&mut **self, node, __ast_path)
+    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
+        <V as Fold>::fold_ts_union_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
-        <V as FoldAstPath>::fold_unary_expr(&mut **self, node, __ast_path)
+    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
+        <V as Fold>::fold_unary_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
-        <V as FoldAstPath>::fold_unary_op(&mut **self, node, __ast_path)
+    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
+        <V as Fold>::fold_unary_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
-        <V as FoldAstPath>::fold_update_expr(&mut **self, node, __ast_path)
+    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
+        <V as Fold>::fold_update_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
-        <V as FoldAstPath>::fold_update_op(&mut **self, node, __ast_path)
+    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
+        <V as Fold>::fold_update_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
-        <V as FoldAstPath>::fold_using_decl(&mut **self, node, __ast_path)
+    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
+        <V as Fold>::fold_using_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
-        <V as FoldAstPath>::fold_var_decl(&mut **self, node, __ast_path)
+    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
+        <V as Fold>::fold_var_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_decl_kind(
-        &mut self,
-        node: VarDeclKind,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclKind {
-        <V as FoldAstPath>::fold_var_decl_kind(&mut **self, node, __ast_path)
+    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
+        <V as Fold>::fold_var_decl_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(
-        &mut self,
-        node: VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclOrExpr {
-        <V as FoldAstPath>::fold_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
+        <V as Fold>::fold_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_declarator(
-        &mut self,
-        node: VarDeclarator,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclarator {
-        <V as FoldAstPath>::fold_var_declarator(&mut **self, node, __ast_path)
+    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
+        <V as Fold>::fold_var_declarator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_declarators(
-        &mut self,
-        node: Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<VarDeclarator> {
-        <V as FoldAstPath>::fold_var_declarators(&mut **self, node, __ast_path)
+    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
+        <V as Fold>::fold_var_declarators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
-        <V as FoldAstPath>::fold_while_stmt(&mut **self, node, __ast_path)
+    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
+        <V as Fold>::fold_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
-        <V as FoldAstPath>::fold_with_stmt(&mut **self, node, __ast_path)
+    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
+        <V as Fold>::fold_with_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
-        <V as FoldAstPath>::fold_yield_expr(&mut **self, node, __ast_path)
+    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
+        <V as Fold>::fold_yield_expr(&mut **self, node)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> FoldAstPath for Box<V>
+impl<V> Fold for Box<V>
 where
-    V: ?Sized + FoldAstPath,
+    V: ?Sized + Fold,
 {
     #[inline]
-    fn fold_accessibility(
-        &mut self,
-        node: Accessibility,
-        __ast_path: &mut AstKindPath,
-    ) -> Accessibility {
-        <V as FoldAstPath>::fold_accessibility(&mut **self, node, __ast_path)
+    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
+        <V as Fold>::fold_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
-        <V as FoldAstPath>::fold_array_lit(&mut **self, node, __ast_path)
+    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
+        <V as Fold>::fold_array_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
-        <V as FoldAstPath>::fold_array_pat(&mut **self, node, __ast_path)
+    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
+        <V as Fold>::fold_array_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
-        <V as FoldAstPath>::fold_arrow_expr(&mut **self, node, __ast_path)
+    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
+        <V as Fold>::fold_arrow_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
-        <V as FoldAstPath>::fold_assign_expr(&mut **self, node, __ast_path)
+    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
+        <V as Fold>::fold_assign_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
-        <V as FoldAstPath>::fold_assign_op(&mut **self, node, __ast_path)
+    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
+        <V as Fold>::fold_assign_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
-        <V as FoldAstPath>::fold_assign_pat(&mut **self, node, __ast_path)
+    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
+        <V as Fold>::fold_assign_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_pat_prop(
-        &mut self,
-        node: AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignPatProp {
-        <V as FoldAstPath>::fold_assign_pat_prop(&mut **self, node, __ast_path)
+    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
+        <V as Fold>::fold_assign_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
-        <V as FoldAstPath>::fold_assign_prop(&mut **self, node, __ast_path)
+    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
+        <V as Fold>::fold_assign_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_target(
-        &mut self,
-        node: AssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTarget {
-        <V as FoldAstPath>::fold_assign_target(&mut **self, node, __ast_path)
+    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
+        <V as Fold>::fold_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn fold_assign_target_pat(
-        &mut self,
-        node: AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTargetPat {
-        <V as FoldAstPath>::fold_assign_target_pat(&mut **self, node, __ast_path)
+    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
+        <V as Fold>::fold_assign_target_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
-        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
+        <V as Fold>::fold_atom(&mut **self, node)
     }
 
     #[inline]
-    fn fold_auto_accessor(
-        &mut self,
-        node: AutoAccessor,
-        __ast_path: &mut AstKindPath,
-    ) -> AutoAccessor {
-        <V as FoldAstPath>::fold_auto_accessor(&mut **self, node, __ast_path)
+    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
+        <V as Fold>::fold_auto_accessor(&mut **self, node)
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
-        <V as FoldAstPath>::fold_await_expr(&mut **self, node, __ast_path)
+    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
+        <V as Fold>::fold_await_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
-        <V as FoldAstPath>::fold_big_int(&mut **self, node, __ast_path)
+    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
+        <V as Fold>::fold_big_int(&mut **self, node)
     }
 
     #[inline]
-    fn fold_big_int_value(
-        &mut self,
-        node: BigIntValue,
-        __ast_path: &mut AstKindPath,
-    ) -> BigIntValue {
-        <V as FoldAstPath>::fold_big_int_value(&mut **self, node, __ast_path)
+    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
+        <V as Fold>::fold_big_int_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
-        <V as FoldAstPath>::fold_bin_expr(&mut **self, node, __ast_path)
+    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
+        <V as Fold>::fold_bin_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
-        <V as FoldAstPath>::fold_binary_op(&mut **self, node, __ast_path)
+    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
+        <V as Fold>::fold_binary_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_binding_ident(
-        &mut self,
-        node: BindingIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> BindingIdent {
-        <V as FoldAstPath>::fold_binding_ident(&mut **self, node, __ast_path)
+    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
+        <V as Fold>::fold_binding_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
-        <V as FoldAstPath>::fold_block_stmt(&mut **self, node, __ast_path)
+    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
+        <V as Fold>::fold_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(
-        &mut self,
-        node: BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> BlockStmtOrExpr {
-        <V as FoldAstPath>::fold_block_stmt_or_expr(&mut **self, node, __ast_path)
+    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
+        <V as Fold>::fold_block_stmt_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
-        <V as FoldAstPath>::fold_bool(&mut **self, node, __ast_path)
+    fn fold_bool(&mut self, node: Bool) -> Bool {
+        <V as Fold>::fold_bool(&mut **self, node)
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
-        <V as FoldAstPath>::fold_break_stmt(&mut **self, node, __ast_path)
+    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
+        <V as Fold>::fold_break_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
-        <V as FoldAstPath>::fold_call_expr(&mut **self, node, __ast_path)
+    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
+        <V as Fold>::fold_call_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
-        <V as FoldAstPath>::fold_callee(&mut **self, node, __ast_path)
+    fn fold_callee(&mut self, node: Callee) -> Callee {
+        <V as Fold>::fold_callee(&mut **self, node)
     }
 
     #[inline]
-    fn fold_catch_clause(
-        &mut self,
-        node: CatchClause,
-        __ast_path: &mut AstKindPath,
-    ) -> CatchClause {
-        <V as FoldAstPath>::fold_catch_clause(&mut **self, node, __ast_path)
+    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
+        <V as Fold>::fold_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
-        <V as FoldAstPath>::fold_class(&mut **self, node, __ast_path)
+    fn fold_class(&mut self, node: Class) -> Class {
+        <V as Fold>::fold_class(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
-        <V as FoldAstPath>::fold_class_decl(&mut **self, node, __ast_path)
+    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
+        <V as Fold>::fold_class_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
-        <V as FoldAstPath>::fold_class_expr(&mut **self, node, __ast_path)
+    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
+        <V as Fold>::fold_class_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_member(
-        &mut self,
-        node: ClassMember,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMember {
-        <V as FoldAstPath>::fold_class_member(&mut **self, node, __ast_path)
+    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
+        <V as Fold>::fold_class_member(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_members(
-        &mut self,
-        node: Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ClassMember> {
-        <V as FoldAstPath>::fold_class_members(&mut **self, node, __ast_path)
+    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
+        <V as Fold>::fold_class_members(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_method(
-        &mut self,
-        node: ClassMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMethod {
-        <V as FoldAstPath>::fold_class_method(&mut **self, node, __ast_path)
+    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
+        <V as Fold>::fold_class_method(&mut **self, node)
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
-        <V as FoldAstPath>::fold_class_prop(&mut **self, node, __ast_path)
+    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
+        <V as Fold>::fold_class_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_computed_prop_name(
-        &mut self,
-        node: ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) -> ComputedPropName {
-        <V as FoldAstPath>::fold_computed_prop_name(&mut **self, node, __ast_path)
+    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
+        <V as Fold>::fold_computed_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
-        <V as FoldAstPath>::fold_cond_expr(&mut **self, node, __ast_path)
+    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
+        <V as Fold>::fold_cond_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
-        <V as FoldAstPath>::fold_constructor(&mut **self, node, __ast_path)
+    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
+        <V as Fold>::fold_constructor(&mut **self, node)
     }
 
     #[inline]
-    fn fold_continue_stmt(
-        &mut self,
-        node: ContinueStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> ContinueStmt {
-        <V as FoldAstPath>::fold_continue_stmt(&mut **self, node, __ast_path)
+    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
+        <V as Fold>::fold_continue_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_debugger_stmt(
-        &mut self,
-        node: DebuggerStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DebuggerStmt {
-        <V as FoldAstPath>::fold_debugger_stmt(&mut **self, node, __ast_path)
+    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
+        <V as Fold>::fold_debugger_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
-        <V as FoldAstPath>::fold_decl(&mut **self, node, __ast_path)
+    fn fold_decl(&mut self, node: Decl) -> Decl {
+        <V as Fold>::fold_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
-        <V as FoldAstPath>::fold_decorator(&mut **self, node, __ast_path)
+    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
+        <V as Fold>::fold_decorator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_decorators(
-        &mut self,
-        node: Vec<Decorator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Decorator> {
-        <V as FoldAstPath>::fold_decorators(&mut **self, node, __ast_path)
+    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
+        <V as Fold>::fold_decorators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_default_decl(
-        &mut self,
-        node: DefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> DefaultDecl {
-        <V as FoldAstPath>::fold_default_decl(&mut **self, node, __ast_path)
+    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
+        <V as Fold>::fold_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_do_while_stmt(
-        &mut self,
-        node: DoWhileStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DoWhileStmt {
-        <V as FoldAstPath>::fold_do_while_stmt(&mut **self, node, __ast_path)
+    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
+        <V as Fold>::fold_do_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
-        <V as FoldAstPath>::fold_empty_stmt(&mut **self, node, __ast_path)
+    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
+        <V as Fold>::fold_empty_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
-        <V as FoldAstPath>::fold_es_version(&mut **self, node, __ast_path)
+    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
+        <V as Fold>::fold_es_version(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
-        <V as FoldAstPath>::fold_export_all(&mut **self, node, __ast_path)
+    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
+        <V as Fold>::fold_export_all(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
-        <V as FoldAstPath>::fold_export_decl(&mut **self, node, __ast_path)
+    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
+        <V as Fold>::fold_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_default_decl(
-        &mut self,
-        node: ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultDecl {
-        <V as FoldAstPath>::fold_export_default_decl(&mut **self, node, __ast_path)
+    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
+        <V as Fold>::fold_export_default_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_default_expr(
-        &mut self,
-        node: ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultExpr {
-        <V as FoldAstPath>::fold_export_default_expr(&mut **self, node, __ast_path)
+    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
+        <V as Fold>::fold_export_default_expr(&mut **self, node)
     }
 
     #[inline]
     fn fold_export_default_specifier(
         &mut self,
         node: ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportDefaultSpecifier {
-        <V as FoldAstPath>::fold_export_default_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_export_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_named_specifier(
-        &mut self,
-        node: ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportNamedSpecifier {
-        <V as FoldAstPath>::fold_export_named_specifier(&mut **self, node, __ast_path)
+    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
+        <V as Fold>::fold_export_named_specifier(&mut **self, node)
     }
 
     #[inline]
     fn fold_export_namespace_specifier(
         &mut self,
         node: ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportNamespaceSpecifier {
-        <V as FoldAstPath>::fold_export_namespace_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_export_namespace_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_specifier(
-        &mut self,
-        node: ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportSpecifier {
-        <V as FoldAstPath>::fold_export_specifier(&mut **self, node, __ast_path)
+    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
+        <V as Fold>::fold_export_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_export_specifiers(
-        &mut self,
-        node: Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExportSpecifier> {
-        <V as FoldAstPath>::fold_export_specifiers(&mut **self, node, __ast_path)
+    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
+        <V as Fold>::fold_export_specifiers(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
-        <V as FoldAstPath>::fold_expr(&mut **self, node, __ast_path)
+    fn fold_expr(&mut self, node: Expr) -> Expr {
+        <V as Fold>::fold_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr_or_spread(
-        &mut self,
-        node: ExprOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> ExprOrSpread {
-        <V as FoldAstPath>::fold_expr_or_spread(&mut **self, node, __ast_path)
+    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
+        <V as Fold>::fold_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr_or_spreads(
-        &mut self,
-        node: Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExprOrSpread> {
-        <V as FoldAstPath>::fold_expr_or_spreads(&mut **self, node, __ast_path)
+    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
+        <V as Fold>::fold_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
-        <V as FoldAstPath>::fold_expr_stmt(&mut **self, node, __ast_path)
+    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
+        <V as Fold>::fold_expr_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
-        <V as FoldAstPath>::fold_exprs(&mut **self, node, __ast_path)
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
+        <V as Fold>::fold_exprs(&mut **self, node)
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
-        <V as FoldAstPath>::fold_fn_decl(&mut **self, node, __ast_path)
+    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
+        <V as Fold>::fold_fn_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
-        <V as FoldAstPath>::fold_fn_expr(&mut **self, node, __ast_path)
+    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
+        <V as Fold>::fold_fn_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
-        <V as FoldAstPath>::fold_for_head(&mut **self, node, __ast_path)
+    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
+        <V as Fold>::fold_for_head(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
-        <V as FoldAstPath>::fold_for_in_stmt(&mut **self, node, __ast_path)
+    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
+        <V as Fold>::fold_for_in_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
-        <V as FoldAstPath>::fold_for_of_stmt(&mut **self, node, __ast_path)
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
+        <V as Fold>::fold_for_of_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
-        <V as FoldAstPath>::fold_for_stmt(&mut **self, node, __ast_path)
+    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
+        <V as Fold>::fold_for_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
-        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
+    fn fold_function(&mut self, node: Function) -> Function {
+        <V as Fold>::fold_function(&mut **self, node)
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
-        <V as FoldAstPath>::fold_getter_prop(&mut **self, node, __ast_path)
+    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
+        <V as Fold>::fold_getter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
-        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
+    fn fold_ident(&mut self, node: Ident) -> Ident {
+        <V as Fold>::fold_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
-        <V as FoldAstPath>::fold_ident_name(&mut **self, node, __ast_path)
+    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
+        <V as Fold>::fold_ident_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
-        <V as FoldAstPath>::fold_if_stmt(&mut **self, node, __ast_path)
+    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
+        <V as Fold>::fold_if_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
-        <V as FoldAstPath>::fold_import(&mut **self, node, __ast_path)
+    fn fold_import(&mut self, node: Import) -> Import {
+        <V as Fold>::fold_import(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
-        <V as FoldAstPath>::fold_import_decl(&mut **self, node, __ast_path)
+    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
+        <V as Fold>::fold_import_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_import_default_specifier(
         &mut self,
         node: ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportDefaultSpecifier {
-        <V as FoldAstPath>::fold_import_default_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_import_default_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_named_specifier(
-        &mut self,
-        node: ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportNamedSpecifier {
-        <V as FoldAstPath>::fold_import_named_specifier(&mut **self, node, __ast_path)
+    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
+        <V as Fold>::fold_import_named_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_phase(
-        &mut self,
-        node: ImportPhase,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPhase {
-        <V as FoldAstPath>::fold_import_phase(&mut **self, node, __ast_path)
+    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
+        <V as Fold>::fold_import_phase(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_specifier(
-        &mut self,
-        node: ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportSpecifier {
-        <V as FoldAstPath>::fold_import_specifier(&mut **self, node, __ast_path)
+    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
+        <V as Fold>::fold_import_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_specifiers(
-        &mut self,
-        node: Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportSpecifier> {
-        <V as FoldAstPath>::fold_import_specifiers(&mut **self, node, __ast_path)
+    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
+        <V as Fold>::fold_import_specifiers(&mut **self, node)
     }
 
     #[inline]
     fn fold_import_star_as_specifier(
         &mut self,
         node: ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportStarAsSpecifier {
-        <V as FoldAstPath>::fold_import_star_as_specifier(&mut **self, node, __ast_path)
+        <V as Fold>::fold_import_star_as_specifier(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
-        <V as FoldAstPath>::fold_import_with(&mut **self, node, __ast_path)
+    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
+        <V as Fold>::fold_import_with(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_with_item(
-        &mut self,
-        node: ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportWithItem {
-        <V as FoldAstPath>::fold_import_with_item(&mut **self, node, __ast_path)
+    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
+        <V as Fold>::fold_import_with_item(&mut **self, node)
     }
 
     #[inline]
-    fn fold_import_with_items(
-        &mut self,
-        node: Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportWithItem> {
-        <V as FoldAstPath>::fold_import_with_items(&mut **self, node, __ast_path)
+    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
+        <V as Fold>::fold_import_with_items(&mut **self, node)
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
-        <V as FoldAstPath>::fold_invalid(&mut **self, node, __ast_path)
+    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
+        <V as Fold>::fold_invalid(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
-        <V as FoldAstPath>::fold_jsx_attr(&mut **self, node, __ast_path)
+    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
+        <V as Fold>::fold_jsx_attr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_name(
-        &mut self,
-        node: JSXAttrName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrName {
-        <V as FoldAstPath>::fold_jsx_attr_name(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
+        <V as Fold>::fold_jsx_attr_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(
-        &mut self,
-        node: JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrOrSpread {
-        <V as FoldAstPath>::fold_jsx_attr_or_spread(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
+        <V as Fold>::fold_jsx_attr_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(
-        &mut self,
-        node: Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXAttrOrSpread> {
-        <V as FoldAstPath>::fold_jsx_attr_or_spreads(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
+        <V as Fold>::fold_jsx_attr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_attr_value(
-        &mut self,
-        node: JSXAttrValue,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrValue {
-        <V as FoldAstPath>::fold_jsx_attr_value(&mut **self, node, __ast_path)
+    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
+        <V as Fold>::fold_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_closing_element(
-        &mut self,
-        node: JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingElement {
-        <V as FoldAstPath>::fold_jsx_closing_element(&mut **self, node, __ast_path)
+    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
+        <V as Fold>::fold_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(
-        &mut self,
-        node: JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingFragment {
-        <V as FoldAstPath>::fold_jsx_closing_fragment(&mut **self, node, __ast_path)
+    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
+        <V as Fold>::fold_jsx_closing_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
-        <V as FoldAstPath>::fold_jsx_element(&mut **self, node, __ast_path)
+    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
+        <V as Fold>::fold_jsx_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element_child(
-        &mut self,
-        node: JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementChild {
-        <V as FoldAstPath>::fold_jsx_element_child(&mut **self, node, __ast_path)
+    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
+        <V as Fold>::fold_jsx_element_child(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element_childs(
-        &mut self,
-        node: Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXElementChild> {
-        <V as FoldAstPath>::fold_jsx_element_childs(&mut **self, node, __ast_path)
+    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
+        <V as Fold>::fold_jsx_element_childs(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_element_name(
-        &mut self,
-        node: JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementName {
-        <V as FoldAstPath>::fold_jsx_element_name(&mut **self, node, __ast_path)
+    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
+        <V as Fold>::fold_jsx_element_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(
-        &mut self,
-        node: JSXEmptyExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXEmptyExpr {
-        <V as FoldAstPath>::fold_jsx_empty_expr(&mut **self, node, __ast_path)
+    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
+        <V as Fold>::fold_jsx_empty_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
-        <V as FoldAstPath>::fold_jsx_expr(&mut **self, node, __ast_path)
+    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
+        <V as Fold>::fold_jsx_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_expr_container(
-        &mut self,
-        node: JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXExprContainer {
-        <V as FoldAstPath>::fold_jsx_expr_container(&mut **self, node, __ast_path)
+    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
+        <V as Fold>::fold_jsx_expr_container(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_fragment(
-        &mut self,
-        node: JSXFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXFragment {
-        <V as FoldAstPath>::fold_jsx_fragment(&mut **self, node, __ast_path)
+    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
+        <V as Fold>::fold_jsx_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_member_expr(
-        &mut self,
-        node: JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXMemberExpr {
-        <V as FoldAstPath>::fold_jsx_member_expr(&mut **self, node, __ast_path)
+    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
+        <V as Fold>::fold_jsx_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(
-        &mut self,
-        node: JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXNamespacedName {
-        <V as FoldAstPath>::fold_jsx_namespaced_name(&mut **self, node, __ast_path)
+    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
+        <V as Fold>::fold_jsx_namespaced_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
-        <V as FoldAstPath>::fold_jsx_object(&mut **self, node, __ast_path)
+    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
+        <V as Fold>::fold_jsx_object(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_opening_element(
-        &mut self,
-        node: JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningElement {
-        <V as FoldAstPath>::fold_jsx_opening_element(&mut **self, node, __ast_path)
+    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
+        <V as Fold>::fold_jsx_opening_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(
-        &mut self,
-        node: JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningFragment {
-        <V as FoldAstPath>::fold_jsx_opening_fragment(&mut **self, node, __ast_path)
+    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
+        <V as Fold>::fold_jsx_opening_fragment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_spread_child(
-        &mut self,
-        node: JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXSpreadChild {
-        <V as FoldAstPath>::fold_jsx_spread_child(&mut **self, node, __ast_path)
+    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
+        <V as Fold>::fold_jsx_spread_child(&mut **self, node)
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
-        <V as FoldAstPath>::fold_jsx_text(&mut **self, node, __ast_path)
+    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
+        <V as Fold>::fold_jsx_text(&mut **self, node)
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
-        <V as FoldAstPath>::fold_key(&mut **self, node, __ast_path)
+    fn fold_key(&mut self, node: Key) -> Key {
+        <V as Fold>::fold_key(&mut **self, node)
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(
-        &mut self,
-        node: KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValuePatProp {
-        <V as FoldAstPath>::fold_key_value_pat_prop(&mut **self, node, __ast_path)
+    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
+        <V as Fold>::fold_key_value_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_key_value_prop(
-        &mut self,
-        node: KeyValueProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValueProp {
-        <V as FoldAstPath>::fold_key_value_prop(&mut **self, node, __ast_path)
+    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
+        <V as Fold>::fold_key_value_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_labeled_stmt(
-        &mut self,
-        node: LabeledStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> LabeledStmt {
-        <V as FoldAstPath>::fold_labeled_stmt(&mut **self, node, __ast_path)
+    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
+        <V as Fold>::fold_labeled_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
-        <V as FoldAstPath>::fold_lit(&mut **self, node, __ast_path)
+    fn fold_lit(&mut self, node: Lit) -> Lit {
+        <V as Fold>::fold_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
-        <V as FoldAstPath>::fold_member_expr(&mut **self, node, __ast_path)
+    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
+        <V as Fold>::fold_member_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
-        <V as FoldAstPath>::fold_member_prop(&mut **self, node, __ast_path)
+    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
+        <V as Fold>::fold_member_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_meta_prop_expr(
-        &mut self,
-        node: MetaPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropExpr {
-        <V as FoldAstPath>::fold_meta_prop_expr(&mut **self, node, __ast_path)
+    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
+        <V as Fold>::fold_meta_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_meta_prop_kind(
-        &mut self,
-        node: MetaPropKind,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropKind {
-        <V as FoldAstPath>::fold_meta_prop_kind(&mut **self, node, __ast_path)
+    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
+        <V as Fold>::fold_meta_prop_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
-        <V as FoldAstPath>::fold_method_kind(&mut **self, node, __ast_path)
+    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
+        <V as Fold>::fold_method_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
-        <V as FoldAstPath>::fold_method_prop(&mut **self, node, __ast_path)
+    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
+        <V as Fold>::fold_method_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
-        <V as FoldAstPath>::fold_module(&mut **self, node, __ast_path)
+    fn fold_module(&mut self, node: Module) -> Module {
+        <V as Fold>::fold_module(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
-        <V as FoldAstPath>::fold_module_decl(&mut **self, node, __ast_path)
+    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
+        <V as Fold>::fold_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_export_name(
-        &mut self,
-        node: ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) -> ModuleExportName {
-        <V as FoldAstPath>::fold_module_export_name(&mut **self, node, __ast_path)
+    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
+        <V as Fold>::fold_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
-        <V as FoldAstPath>::fold_module_item(&mut **self, node, __ast_path)
+    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
+        <V as Fold>::fold_module_item(&mut **self, node)
     }
 
     #[inline]
-    fn fold_module_items(
-        &mut self,
-        node: Vec<ModuleItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ModuleItem> {
-        <V as FoldAstPath>::fold_module_items(&mut **self, node, __ast_path)
+    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
+        <V as Fold>::fold_module_items(&mut **self, node)
     }
 
     #[inline]
-    fn fold_named_export(
-        &mut self,
-        node: NamedExport,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedExport {
-        <V as FoldAstPath>::fold_named_export(&mut **self, node, __ast_path)
+    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
+        <V as Fold>::fold_named_export(&mut **self, node)
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
-        <V as FoldAstPath>::fold_new_expr(&mut **self, node, __ast_path)
+    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
+        <V as Fold>::fold_new_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
-        <V as FoldAstPath>::fold_null(&mut **self, node, __ast_path)
+    fn fold_null(&mut self, node: Null) -> Null {
+        <V as Fold>::fold_null(&mut **self, node)
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
-        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
+    fn fold_number(&mut self, node: Number) -> Number {
+        <V as Fold>::fold_number(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
-        <V as FoldAstPath>::fold_object_lit(&mut **self, node, __ast_path)
+    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
+        <V as Fold>::fold_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
-        <V as FoldAstPath>::fold_object_pat(&mut **self, node, __ast_path)
+    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
+        <V as Fold>::fold_object_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_pat_prop(
-        &mut self,
-        node: ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ObjectPatProp {
-        <V as FoldAstPath>::fold_object_pat_prop(&mut **self, node, __ast_path)
+    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
+        <V as Fold>::fold_object_pat_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_object_pat_props(
-        &mut self,
-        node: Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ObjectPatProp> {
-        <V as FoldAstPath>::fold_object_pat_props(&mut **self, node, __ast_path)
+    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
+        <V as Fold>::fold_object_pat_props(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_accessibility(
-        &mut self,
-        node: Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Accessibility> {
-        <V as FoldAstPath>::fold_opt_accessibility(&mut **self, node, __ast_path)
+    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
+        <V as Fold>::fold_opt_accessibility(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
-        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
+        <V as Fold>::fold_opt_atom(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_block_stmt(
-        &mut self,
-        node: Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<BlockStmt> {
-        <V as FoldAstPath>::fold_opt_block_stmt(&mut **self, node, __ast_path)
+    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
+        <V as Fold>::fold_opt_block_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
-        <V as FoldAstPath>::fold_opt_call(&mut **self, node, __ast_path)
+    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
+        <V as Fold>::fold_opt_call(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_catch_clause(
-        &mut self,
-        node: Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<CatchClause> {
-        <V as FoldAstPath>::fold_opt_catch_clause(&mut **self, node, __ast_path)
+    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
+        <V as Fold>::fold_opt_catch_clause(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_chain_base(
-        &mut self,
-        node: OptChainBase,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainBase {
-        <V as FoldAstPath>::fold_opt_chain_base(&mut **self, node, __ast_path)
+    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
+        <V as Fold>::fold_opt_chain_base(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_chain_expr(
-        &mut self,
-        node: OptChainExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainExpr {
-        <V as FoldAstPath>::fold_opt_chain_expr(&mut **self, node, __ast_path)
+    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
+        <V as Fold>::fold_opt_chain_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_expr(
-        &mut self,
-        node: Option<Box<Expr>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Expr>> {
-        <V as FoldAstPath>::fold_opt_expr(&mut **self, node, __ast_path)
+    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
+        <V as Fold>::fold_opt_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(
-        &mut self,
-        node: Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ExprOrSpread> {
-        <V as FoldAstPath>::fold_opt_expr_or_spread(&mut **self, node, __ast_path)
+    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
+        <V as Fold>::fold_opt_expr_or_spread(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_expr_or_spreads(
         &mut self,
         node: Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<ExprOrSpread>> {
-        <V as FoldAstPath>::fold_opt_expr_or_spreads(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
-        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
+        <V as Fold>::fold_opt_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(
-        &mut self,
-        node: Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<JSXAttrValue> {
-        <V as FoldAstPath>::fold_opt_jsx_attr_value(&mut **self, node, __ast_path)
+    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
+        <V as Fold>::fold_opt_jsx_attr_value(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_jsx_closing_element(
         &mut self,
         node: Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<JSXClosingElement> {
-        <V as FoldAstPath>::fold_opt_jsx_closing_element(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_jsx_closing_element(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_module_export_name(
         &mut self,
         node: Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ModuleExportName> {
-        <V as FoldAstPath>::fold_opt_module_export_name(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_module_export_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_object_lit(
-        &mut self,
-        node: Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<ObjectLit>> {
-        <V as FoldAstPath>::fold_opt_object_lit(&mut **self, node, __ast_path)
+    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
+        <V as Fold>::fold_opt_object_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
-        <V as FoldAstPath>::fold_opt_pat(&mut **self, node, __ast_path)
+    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
+        <V as Fold>::fold_opt_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_span(
-        &mut self,
-        node: Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_common::Span> {
-        <V as FoldAstPath>::fold_opt_span(&mut **self, node, __ast_path)
+    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
+        <V as Fold>::fold_opt_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_stmt(
-        &mut self,
-        node: Option<Box<Stmt>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Stmt>> {
-        <V as FoldAstPath>::fold_opt_stmt(&mut **self, node, __ast_path)
+    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
+        <V as Fold>::fold_opt_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_str(
-        &mut self,
-        node: Option<Box<Str>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Str>> {
-        <V as FoldAstPath>::fold_opt_str(&mut **self, node, __ast_path)
+    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
+        <V as Fold>::fold_opt_str(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(
-        &mut self,
-        node: Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TruePlusMinus> {
-        <V as FoldAstPath>::fold_opt_true_plus_minus(&mut **self, node, __ast_path)
+    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
+        <V as Fold>::fold_opt_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(
-        &mut self,
-        node: Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TsEntityName> {
-        <V as FoldAstPath>::fold_opt_ts_entity_name(&mut **self, node, __ast_path)
+    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
+        <V as Fold>::fold_opt_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_ts_namespace_body(
         &mut self,
         node: Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<TsNamespaceBody> {
-        <V as FoldAstPath>::fold_opt_ts_namespace_body(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ts_type(
-        &mut self,
-        node: Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsType>> {
-        <V as FoldAstPath>::fold_opt_ts_type(&mut **self, node, __ast_path)
+    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
+        <V as Fold>::fold_opt_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(
-        &mut self,
-        node: Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsTypeAnn>> {
-        <V as FoldAstPath>::fold_opt_ts_type_ann(&mut **self, node, __ast_path)
+    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
+        <V as Fold>::fold_opt_ts_type_ann(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_ts_type_param_decl(
         &mut self,
         node: Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamDecl>> {
-        <V as FoldAstPath>::fold_opt_ts_type_param_decl(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_ts_type_param_instantiation(
         &mut self,
         node: Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamInstantiation>> {
-        <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(
-        &mut self,
-        node: Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<VarDeclOrExpr> {
-        <V as FoldAstPath>::fold_opt_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
+        <V as Fold>::fold_opt_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
     fn fold_opt_vec_expr_or_spreads(
         &mut self,
         node: Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<Option<ExprOrSpread>> {
-        <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
+        <V as Fold>::fold_opt_vec_expr_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_opt_vec_pats(
-        &mut self,
-        node: Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Option<Pat>> {
-        <V as FoldAstPath>::fold_opt_vec_pats(&mut **self, node, __ast_path)
+    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
+        <V as Fold>::fold_opt_vec_pats(&mut **self, node)
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
-        <V as FoldAstPath>::fold_param(&mut **self, node, __ast_path)
+    fn fold_param(&mut self, node: Param) -> Param {
+        <V as Fold>::fold_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(
-        &mut self,
-        node: ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ParamOrTsParamProp {
-        <V as FoldAstPath>::fold_param_or_ts_param_prop(&mut **self, node, __ast_path)
+    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
+        <V as Fold>::fold_param_or_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
     fn fold_param_or_ts_param_props(
         &mut self,
         node: Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ParamOrTsParamProp> {
-        <V as FoldAstPath>::fold_param_or_ts_param_props(&mut **self, node, __ast_path)
+        <V as Fold>::fold_param_or_ts_param_props(&mut **self, node)
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
-        <V as FoldAstPath>::fold_params(&mut **self, node, __ast_path)
+    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
+        <V as Fold>::fold_params(&mut **self, node)
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
-        <V as FoldAstPath>::fold_paren_expr(&mut **self, node, __ast_path)
+    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
+        <V as Fold>::fold_paren_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
-        <V as FoldAstPath>::fold_pat(&mut **self, node, __ast_path)
+    fn fold_pat(&mut self, node: Pat) -> Pat {
+        <V as Fold>::fold_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
-        <V as FoldAstPath>::fold_pats(&mut **self, node, __ast_path)
+    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
+        <V as Fold>::fold_pats(&mut **self, node)
     }
 
     #[inline]
-    fn fold_private_method(
-        &mut self,
-        node: PrivateMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateMethod {
-        <V as FoldAstPath>::fold_private_method(&mut **self, node, __ast_path)
+    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
+        <V as Fold>::fold_private_method(&mut **self, node)
     }
 
     #[inline]
-    fn fold_private_name(
-        &mut self,
-        node: PrivateName,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateName {
-        <V as FoldAstPath>::fold_private_name(&mut **self, node, __ast_path)
+    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
+        <V as Fold>::fold_private_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_private_prop(
-        &mut self,
-        node: PrivateProp,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateProp {
-        <V as FoldAstPath>::fold_private_prop(&mut **self, node, __ast_path)
+    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
+        <V as Fold>::fold_private_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
-        <V as FoldAstPath>::fold_program(&mut **self, node, __ast_path)
+    fn fold_program(&mut self, node: Program) -> Program {
+        <V as Fold>::fold_program(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
-        <V as FoldAstPath>::fold_prop(&mut **self, node, __ast_path)
+    fn fold_prop(&mut self, node: Prop) -> Prop {
+        <V as Fold>::fold_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
-        <V as FoldAstPath>::fold_prop_name(&mut **self, node, __ast_path)
+    fn fold_prop_name(&mut self, node: PropName) -> PropName {
+        <V as Fold>::fold_prop_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop_or_spread(
-        &mut self,
-        node: PropOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> PropOrSpread {
-        <V as FoldAstPath>::fold_prop_or_spread(&mut **self, node, __ast_path)
+    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
+        <V as Fold>::fold_prop_or_spread(&mut **self, node)
     }
 
     #[inline]
-    fn fold_prop_or_spreads(
-        &mut self,
-        node: Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PropOrSpread> {
-        <V as FoldAstPath>::fold_prop_or_spreads(&mut **self, node, __ast_path)
+    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
+        <V as Fold>::fold_prop_or_spreads(&mut **self, node)
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
-        <V as FoldAstPath>::fold_regex(&mut **self, node, __ast_path)
+    fn fold_regex(&mut self, node: Regex) -> Regex {
+        <V as Fold>::fold_regex(&mut **self, node)
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
-        <V as FoldAstPath>::fold_rest_pat(&mut **self, node, __ast_path)
+    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
+        <V as Fold>::fold_rest_pat(&mut **self, node)
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
-        <V as FoldAstPath>::fold_return_stmt(&mut **self, node, __ast_path)
+    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
+        <V as Fold>::fold_return_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
-        <V as FoldAstPath>::fold_script(&mut **self, node, __ast_path)
+    fn fold_script(&mut self, node: Script) -> Script {
+        <V as Fold>::fold_script(&mut **self, node)
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
-        <V as FoldAstPath>::fold_seq_expr(&mut **self, node, __ast_path)
+    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
+        <V as Fold>::fold_seq_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
-        <V as FoldAstPath>::fold_setter_prop(&mut **self, node, __ast_path)
+    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
+        <V as Fold>::fold_setter_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_simple_assign_target(
-        &mut self,
-        node: SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleAssignTarget {
-        <V as FoldAstPath>::fold_simple_assign_target(&mut **self, node, __ast_path)
+    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
+        <V as Fold>::fold_simple_assign_target(&mut **self, node)
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
-        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
+        <V as Fold>::fold_span(&mut **self, node)
     }
 
     #[inline]
-    fn fold_spread_element(
-        &mut self,
-        node: SpreadElement,
-        __ast_path: &mut AstKindPath,
-    ) -> SpreadElement {
-        <V as FoldAstPath>::fold_spread_element(&mut **self, node, __ast_path)
+    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
+        <V as Fold>::fold_spread_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_static_block(
-        &mut self,
-        node: StaticBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> StaticBlock {
-        <V as FoldAstPath>::fold_static_block(&mut **self, node, __ast_path)
+    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
+        <V as Fold>::fold_static_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
-        <V as FoldAstPath>::fold_stmt(&mut **self, node, __ast_path)
+    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
+        <V as Fold>::fold_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
-        <V as FoldAstPath>::fold_stmts(&mut **self, node, __ast_path)
+    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
+        <V as Fold>::fold_stmts(&mut **self, node)
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
-        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
+    fn fold_str(&mut self, node: Str) -> Str {
+        <V as Fold>::fold_str(&mut **self, node)
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
-        <V as FoldAstPath>::fold_super(&mut **self, node, __ast_path)
+    fn fold_super(&mut self, node: Super) -> Super {
+        <V as Fold>::fold_super(&mut **self, node)
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
-        <V as FoldAstPath>::fold_super_prop(&mut **self, node, __ast_path)
+    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
+        <V as Fold>::fold_super_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_super_prop_expr(
-        &mut self,
-        node: SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> SuperPropExpr {
-        <V as FoldAstPath>::fold_super_prop_expr(&mut **self, node, __ast_path)
+    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
+        <V as Fold>::fold_super_prop_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
-        <V as FoldAstPath>::fold_switch_case(&mut **self, node, __ast_path)
+    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
+        <V as Fold>::fold_switch_case(&mut **self, node)
     }
 
     #[inline]
-    fn fold_switch_cases(
-        &mut self,
-        node: Vec<SwitchCase>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SwitchCase> {
-        <V as FoldAstPath>::fold_switch_cases(&mut **self, node, __ast_path)
+    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
+        <V as Fold>::fold_switch_cases(&mut **self, node)
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
-        <V as FoldAstPath>::fold_switch_stmt(&mut **self, node, __ast_path)
+    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
+        <V as Fold>::fold_switch_stmt(&mut **self, node)
     }
 
     #[inline]
     fn fold_syntax_context(
         &mut self,
         node: swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
     ) -> swc_common::SyntaxContext {
-        <V as FoldAstPath>::fold_syntax_context(&mut **self, node, __ast_path)
+        <V as Fold>::fold_syntax_context(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
-        <V as FoldAstPath>::fold_tagged_tpl(&mut **self, node, __ast_path)
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
+        <V as Fold>::fold_tagged_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
-        <V as FoldAstPath>::fold_this_expr(&mut **self, node, __ast_path)
+    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
+        <V as Fold>::fold_this_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
-        <V as FoldAstPath>::fold_throw_stmt(&mut **self, node, __ast_path)
+    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
+        <V as Fold>::fold_throw_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
-        <V as FoldAstPath>::fold_tpl(&mut **self, node, __ast_path)
+    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
+        <V as Fold>::fold_tpl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
-        <V as FoldAstPath>::fold_tpl_element(&mut **self, node, __ast_path)
+    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
+        <V as Fold>::fold_tpl_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_tpl_elements(
-        &mut self,
-        node: Vec<TplElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TplElement> {
-        <V as FoldAstPath>::fold_tpl_elements(&mut **self, node, __ast_path)
+    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
+        <V as Fold>::fold_tpl_elements(&mut **self, node)
     }
 
     #[inline]
-    fn fold_true_plus_minus(
-        &mut self,
-        node: TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) -> TruePlusMinus {
-        <V as FoldAstPath>::fold_true_plus_minus(&mut **self, node, __ast_path)
+    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
+        <V as Fold>::fold_true_plus_minus(&mut **self, node)
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
-        <V as FoldAstPath>::fold_try_stmt(&mut **self, node, __ast_path)
+    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
+        <V as Fold>::fold_try_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_array_type(
-        &mut self,
-        node: TsArrayType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsArrayType {
-        <V as FoldAstPath>::fold_ts_array_type(&mut **self, node, __ast_path)
+    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
+        <V as Fold>::fold_ts_array_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
-        <V as FoldAstPath>::fold_ts_as_expr(&mut **self, node, __ast_path)
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
+        <V as Fold>::fold_ts_as_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(
-        &mut self,
-        node: TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsCallSignatureDecl {
-        <V as FoldAstPath>::fold_ts_call_signature_decl(&mut **self, node, __ast_path)
+    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
+        <V as Fold>::fold_ts_call_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_conditional_type(
-        &mut self,
-        node: TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConditionalType {
-        <V as FoldAstPath>::fold_ts_conditional_type(&mut **self, node, __ast_path)
+    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
+        <V as Fold>::fold_ts_conditional_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_const_assertion(
-        &mut self,
-        node: TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstAssertion {
-        <V as FoldAstPath>::fold_ts_const_assertion(&mut **self, node, __ast_path)
+    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
+        <V as Fold>::fold_ts_const_assertion(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_construct_signature_decl(
         &mut self,
         node: TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsConstructSignatureDecl {
-        <V as FoldAstPath>::fold_ts_construct_signature_decl(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_construct_signature_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_constructor_type(
-        &mut self,
-        node: TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstructorType {
-        <V as FoldAstPath>::fold_ts_constructor_type(&mut **self, node, __ast_path)
+    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
+        <V as Fold>::fold_ts_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_entity_name(
-        &mut self,
-        node: TsEntityName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEntityName {
-        <V as FoldAstPath>::fold_ts_entity_name(&mut **self, node, __ast_path)
+    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
+        <V as Fold>::fold_ts_entity_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
-        <V as FoldAstPath>::fold_ts_enum_decl(&mut **self, node, __ast_path)
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
+        <V as Fold>::fold_ts_enum_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_member(
-        &mut self,
-        node: TsEnumMember,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMember {
-        <V as FoldAstPath>::fold_ts_enum_member(&mut **self, node, __ast_path)
+    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
+        <V as Fold>::fold_ts_enum_member(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(
-        &mut self,
-        node: TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMemberId {
-        <V as FoldAstPath>::fold_ts_enum_member_id(&mut **self, node, __ast_path)
+    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
+        <V as Fold>::fold_ts_enum_member_id(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_enum_members(
-        &mut self,
-        node: Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsEnumMember> {
-        <V as FoldAstPath>::fold_ts_enum_members(&mut **self, node, __ast_path)
+    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
+        <V as Fold>::fold_ts_enum_members(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_export_assignment(
-        &mut self,
-        node: TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExportAssignment {
-        <V as FoldAstPath>::fold_ts_export_assignment(&mut **self, node, __ast_path)
+    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
+        <V as Fold>::fold_ts_export_assignment(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(
-        &mut self,
-        node: TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExprWithTypeArgs {
-        <V as FoldAstPath>::fold_ts_expr_with_type_args(&mut **self, node, __ast_path)
+    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
+        <V as Fold>::fold_ts_expr_with_type_args(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_expr_with_type_argss(
         &mut self,
         node: Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<TsExprWithTypeArgs> {
-        <V as FoldAstPath>::fold_ts_expr_with_type_argss(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_expr_with_type_argss(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(
-        &mut self,
-        node: TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExternalModuleRef {
-        <V as FoldAstPath>::fold_ts_external_module_ref(&mut **self, node, __ast_path)
+    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
+        <V as Fold>::fold_ts_external_module_ref(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_fn_or_constructor_type(
         &mut self,
         node: TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
     ) -> TsFnOrConstructorType {
-        <V as FoldAstPath>::fold_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_fn_or_constructor_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
-        <V as FoldAstPath>::fold_ts_fn_param(&mut **self, node, __ast_path)
+    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
+        <V as Fold>::fold_ts_fn_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_fn_params(
-        &mut self,
-        node: Vec<TsFnParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsFnParam> {
-        <V as FoldAstPath>::fold_ts_fn_params(&mut **self, node, __ast_path)
+    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
+        <V as Fold>::fold_ts_fn_params(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
-        <V as FoldAstPath>::fold_ts_fn_type(&mut **self, node, __ast_path)
+    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
+        <V as Fold>::fold_ts_fn_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_getter_signature(
-        &mut self,
-        node: TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsGetterSignature {
-        <V as FoldAstPath>::fold_ts_getter_signature(&mut **self, node, __ast_path)
+    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
+        <V as Fold>::fold_ts_getter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(
-        &mut self,
-        node: TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportEqualsDecl {
-        <V as FoldAstPath>::fold_ts_import_equals_decl(&mut **self, node, __ast_path)
+    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
+        <V as Fold>::fold_ts_import_equals_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_import_type(
-        &mut self,
-        node: TsImportType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportType {
-        <V as FoldAstPath>::fold_ts_import_type(&mut **self, node, __ast_path)
+    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
+        <V as Fold>::fold_ts_import_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_index_signature(
-        &mut self,
-        node: TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexSignature {
-        <V as FoldAstPath>::fold_ts_index_signature(&mut **self, node, __ast_path)
+    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
+        <V as Fold>::fold_ts_index_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(
-        &mut self,
-        node: TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexedAccessType {
-        <V as FoldAstPath>::fold_ts_indexed_access_type(&mut **self, node, __ast_path)
+    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
+        <V as Fold>::fold_ts_indexed_access_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_infer_type(
-        &mut self,
-        node: TsInferType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInferType {
-        <V as FoldAstPath>::fold_ts_infer_type(&mut **self, node, __ast_path)
+    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
+        <V as Fold>::fold_ts_infer_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_instantiation(
-        &mut self,
-        node: TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInstantiation {
-        <V as FoldAstPath>::fold_ts_instantiation(&mut **self, node, __ast_path)
+    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
+        <V as Fold>::fold_ts_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_interface_body(
-        &mut self,
-        node: TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceBody {
-        <V as FoldAstPath>::fold_ts_interface_body(&mut **self, node, __ast_path)
+    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
+        <V as Fold>::fold_ts_interface_body(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_interface_decl(
-        &mut self,
-        node: TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceDecl {
-        <V as FoldAstPath>::fold_ts_interface_decl(&mut **self, node, __ast_path)
+    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
+        <V as Fold>::fold_ts_interface_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_intersection_type(
-        &mut self,
-        node: TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIntersectionType {
-        <V as FoldAstPath>::fold_ts_intersection_type(&mut **self, node, __ast_path)
+    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
+        <V as Fold>::fold_ts_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_keyword_type(
-        &mut self,
-        node: TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordType {
-        <V as FoldAstPath>::fold_ts_keyword_type(&mut **self, node, __ast_path)
+    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
+        <V as Fold>::fold_ts_keyword_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(
-        &mut self,
-        node: TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordTypeKind {
-        <V as FoldAstPath>::fold_ts_keyword_type_kind(&mut **self, node, __ast_path)
+    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
+        <V as Fold>::fold_ts_keyword_type_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
-        <V as FoldAstPath>::fold_ts_lit(&mut **self, node, __ast_path)
+    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
+        <V as Fold>::fold_ts_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
-        <V as FoldAstPath>::fold_ts_lit_type(&mut **self, node, __ast_path)
+    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
+        <V as Fold>::fold_ts_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_mapped_type(
-        &mut self,
-        node: TsMappedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMappedType {
-        <V as FoldAstPath>::fold_ts_mapped_type(&mut **self, node, __ast_path)
+    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
+        <V as Fold>::fold_ts_mapped_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_method_signature(
-        &mut self,
-        node: TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMethodSignature {
-        <V as FoldAstPath>::fold_ts_method_signature(&mut **self, node, __ast_path)
+    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
+        <V as Fold>::fold_ts_method_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_block(
-        &mut self,
-        node: TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleBlock {
-        <V as FoldAstPath>::fold_ts_module_block(&mut **self, node, __ast_path)
+    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
+        <V as Fold>::fold_ts_module_block(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_decl(
-        &mut self,
-        node: TsModuleDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleDecl {
-        <V as FoldAstPath>::fold_ts_module_decl(&mut **self, node, __ast_path)
+    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
+        <V as Fold>::fold_ts_module_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_name(
-        &mut self,
-        node: TsModuleName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleName {
-        <V as FoldAstPath>::fold_ts_module_name(&mut **self, node, __ast_path)
+    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
+        <V as Fold>::fold_ts_module_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_module_ref(
-        &mut self,
-        node: TsModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleRef {
-        <V as FoldAstPath>::fold_ts_module_ref(&mut **self, node, __ast_path)
+    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
+        <V as Fold>::fold_ts_module_ref(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_namespace_body(
-        &mut self,
-        node: TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceBody {
-        <V as FoldAstPath>::fold_ts_namespace_body(&mut **self, node, __ast_path)
+    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
+        <V as Fold>::fold_ts_namespace_body(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(
-        &mut self,
-        node: TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceDecl {
-        <V as FoldAstPath>::fold_ts_namespace_decl(&mut **self, node, __ast_path)
+    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
+        <V as Fold>::fold_ts_namespace_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_namespace_export_decl(
         &mut self,
         node: TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsNamespaceExportDecl {
-        <V as FoldAstPath>::fold_ts_namespace_export_decl(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_namespace_export_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(
-        &mut self,
-        node: TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNonNullExpr {
-        <V as FoldAstPath>::fold_ts_non_null_expr(&mut **self, node, __ast_path)
+    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
+        <V as Fold>::fold_ts_non_null_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_optional_type(
-        &mut self,
-        node: TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsOptionalType {
-        <V as FoldAstPath>::fold_ts_optional_type(&mut **self, node, __ast_path)
+    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
+        <V as Fold>::fold_ts_optional_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_param_prop(
-        &mut self,
-        node: TsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamProp {
-        <V as FoldAstPath>::fold_ts_param_prop(&mut **self, node, __ast_path)
+    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
+        <V as Fold>::fold_ts_param_prop(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(
-        &mut self,
-        node: TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamPropParam {
-        <V as FoldAstPath>::fold_ts_param_prop_param(&mut **self, node, __ast_path)
+    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
+        <V as Fold>::fold_ts_param_prop_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(
-        &mut self,
-        node: TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParenthesizedType {
-        <V as FoldAstPath>::fold_ts_parenthesized_type(&mut **self, node, __ast_path)
+    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
+        <V as Fold>::fold_ts_parenthesized_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_property_signature(
-        &mut self,
-        node: TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsPropertySignature {
-        <V as FoldAstPath>::fold_ts_property_signature(&mut **self, node, __ast_path)
+    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
+        <V as Fold>::fold_ts_property_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_qualified_name(
-        &mut self,
-        node: TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsQualifiedName {
-        <V as FoldAstPath>::fold_ts_qualified_name(&mut **self, node, __ast_path)
+    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
+        <V as Fold>::fold_ts_qualified_name(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
-        <V as FoldAstPath>::fold_ts_rest_type(&mut **self, node, __ast_path)
+    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
+        <V as Fold>::fold_ts_rest_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(
-        &mut self,
-        node: TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSatisfiesExpr {
-        <V as FoldAstPath>::fold_ts_satisfies_expr(&mut **self, node, __ast_path)
+    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
+        <V as Fold>::fold_ts_satisfies_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_setter_signature(
-        &mut self,
-        node: TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSetterSignature {
-        <V as FoldAstPath>::fold_ts_setter_signature(&mut **self, node, __ast_path)
+    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
+        <V as Fold>::fold_ts_setter_signature(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
-        <V as FoldAstPath>::fold_ts_this_type(&mut **self, node, __ast_path)
+    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
+        <V as Fold>::fold_ts_this_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(
-        &mut self,
-        node: TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> TsThisTypeOrIdent {
-        <V as FoldAstPath>::fold_ts_this_type_or_ident(&mut **self, node, __ast_path)
+    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
+        <V as Fold>::fold_ts_this_type_or_ident(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(
-        &mut self,
-        node: TsTplLitType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTplLitType {
-        <V as FoldAstPath>::fold_ts_tpl_lit_type(&mut **self, node, __ast_path)
+    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
+        <V as Fold>::fold_ts_tpl_lit_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tuple_element(
-        &mut self,
-        node: TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleElement {
-        <V as FoldAstPath>::fold_ts_tuple_element(&mut **self, node, __ast_path)
+    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
+        <V as Fold>::fold_ts_tuple_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(
-        &mut self,
-        node: Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTupleElement> {
-        <V as FoldAstPath>::fold_ts_tuple_elements(&mut **self, node, __ast_path)
+    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
+        <V as Fold>::fold_ts_tuple_elements(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_tuple_type(
-        &mut self,
-        node: TsTupleType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleType {
-        <V as FoldAstPath>::fold_ts_tuple_type(&mut **self, node, __ast_path)
+    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
+        <V as Fold>::fold_ts_tuple_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
-        <V as FoldAstPath>::fold_ts_type(&mut **self, node, __ast_path)
+    fn fold_ts_type(&mut self, node: TsType) -> TsType {
+        <V as Fold>::fold_ts_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(
-        &mut self,
-        node: TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAliasDecl {
-        <V as FoldAstPath>::fold_ts_type_alias_decl(&mut **self, node, __ast_path)
+    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
+        <V as Fold>::fold_ts_type_alias_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
-        <V as FoldAstPath>::fold_ts_type_ann(&mut **self, node, __ast_path)
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
+        <V as Fold>::fold_ts_type_ann(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_assertion(
-        &mut self,
-        node: TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAssertion {
-        <V as FoldAstPath>::fold_ts_type_assertion(&mut **self, node, __ast_path)
+    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
+        <V as Fold>::fold_ts_type_assertion(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_element(
-        &mut self,
-        node: TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeElement {
-        <V as FoldAstPath>::fold_ts_type_element(&mut **self, node, __ast_path)
+    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
+        <V as Fold>::fold_ts_type_element(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_elements(
-        &mut self,
-        node: Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeElement> {
-        <V as FoldAstPath>::fold_ts_type_elements(&mut **self, node, __ast_path)
+    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
+        <V as Fold>::fold_ts_type_elements(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
-        <V as FoldAstPath>::fold_ts_type_lit(&mut **self, node, __ast_path)
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
+        <V as Fold>::fold_ts_type_lit(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_operator(
-        &mut self,
-        node: TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperator {
-        <V as FoldAstPath>::fold_ts_type_operator(&mut **self, node, __ast_path)
+    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
+        <V as Fold>::fold_ts_type_operator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(
-        &mut self,
-        node: TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperatorOp {
-        <V as FoldAstPath>::fold_ts_type_operator_op(&mut **self, node, __ast_path)
+    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
+        <V as Fold>::fold_ts_type_operator_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_param(
-        &mut self,
-        node: TsTypeParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParam {
-        <V as FoldAstPath>::fold_ts_type_param(&mut **self, node, __ast_path)
+    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
+        <V as Fold>::fold_ts_type_param(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(
-        &mut self,
-        node: TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParamDecl {
-        <V as FoldAstPath>::fold_ts_type_param_decl(&mut **self, node, __ast_path)
+    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
+        <V as Fold>::fold_ts_type_param_decl(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_type_param_instantiation(
         &mut self,
         node: TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
     ) -> TsTypeParamInstantiation {
-        <V as FoldAstPath>::fold_ts_type_param_instantiation(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_type_param_instantiation(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_params(
-        &mut self,
-        node: Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeParam> {
-        <V as FoldAstPath>::fold_ts_type_params(&mut **self, node, __ast_path)
+    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
+        <V as Fold>::fold_ts_type_params(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_predicate(
-        &mut self,
-        node: TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypePredicate {
-        <V as FoldAstPath>::fold_ts_type_predicate(&mut **self, node, __ast_path)
+    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
+        <V as Fold>::fold_ts_type_predicate(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_query(
-        &mut self,
-        node: TsTypeQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQuery {
-        <V as FoldAstPath>::fold_ts_type_query(&mut **self, node, __ast_path)
+    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
+        <V as Fold>::fold_ts_type_query(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(
-        &mut self,
-        node: TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQueryExpr {
-        <V as FoldAstPath>::fold_ts_type_query_expr(&mut **self, node, __ast_path)
+    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
+        <V as Fold>::fold_ts_type_query_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
-        <V as FoldAstPath>::fold_ts_type_ref(&mut **self, node, __ast_path)
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
+        <V as Fold>::fold_ts_type_ref(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_types(
-        &mut self,
-        node: Vec<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Box<TsType>> {
-        <V as FoldAstPath>::fold_ts_types(&mut **self, node, __ast_path)
+    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
+        <V as Fold>::fold_ts_types(&mut **self, node)
     }
 
     #[inline]
     fn fold_ts_union_or_intersection_type(
         &mut self,
         node: TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
     ) -> TsUnionOrIntersectionType {
-        <V as FoldAstPath>::fold_ts_union_or_intersection_type(&mut **self, node, __ast_path)
+        <V as Fold>::fold_ts_union_or_intersection_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_ts_union_type(
-        &mut self,
-        node: TsUnionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsUnionType {
-        <V as FoldAstPath>::fold_ts_union_type(&mut **self, node, __ast_path)
+    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
+        <V as Fold>::fold_ts_union_type(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
-        <V as FoldAstPath>::fold_unary_expr(&mut **self, node, __ast_path)
+    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
+        <V as Fold>::fold_unary_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
-        <V as FoldAstPath>::fold_unary_op(&mut **self, node, __ast_path)
+    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
+        <V as Fold>::fold_unary_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
-        <V as FoldAstPath>::fold_update_expr(&mut **self, node, __ast_path)
+    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
+        <V as Fold>::fold_update_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
-        <V as FoldAstPath>::fold_update_op(&mut **self, node, __ast_path)
+    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
+        <V as Fold>::fold_update_op(&mut **self, node)
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
-        <V as FoldAstPath>::fold_using_decl(&mut **self, node, __ast_path)
+    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
+        <V as Fold>::fold_using_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
-        <V as FoldAstPath>::fold_var_decl(&mut **self, node, __ast_path)
+    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
+        <V as Fold>::fold_var_decl(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_decl_kind(
-        &mut self,
-        node: VarDeclKind,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclKind {
-        <V as FoldAstPath>::fold_var_decl_kind(&mut **self, node, __ast_path)
+    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
+        <V as Fold>::fold_var_decl_kind(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(
-        &mut self,
-        node: VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclOrExpr {
-        <V as FoldAstPath>::fold_var_decl_or_expr(&mut **self, node, __ast_path)
+    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
+        <V as Fold>::fold_var_decl_or_expr(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_declarator(
-        &mut self,
-        node: VarDeclarator,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclarator {
-        <V as FoldAstPath>::fold_var_declarator(&mut **self, node, __ast_path)
+    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
+        <V as Fold>::fold_var_declarator(&mut **self, node)
     }
 
     #[inline]
-    fn fold_var_declarators(
-        &mut self,
-        node: Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<VarDeclarator> {
-        <V as FoldAstPath>::fold_var_declarators(&mut **self, node, __ast_path)
+    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
+        <V as Fold>::fold_var_declarators(&mut **self, node)
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
-        <V as FoldAstPath>::fold_while_stmt(&mut **self, node, __ast_path)
+    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
+        <V as Fold>::fold_while_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
-        <V as FoldAstPath>::fold_with_stmt(&mut **self, node, __ast_path)
+    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
+        <V as Fold>::fold_with_stmt(&mut **self, node)
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
-        <V as FoldAstPath>::fold_yield_expr(&mut **self, node, __ast_path)
+    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
+        <V as Fold>::fold_yield_expr(&mut **self, node)
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<A, B> FoldAstPath for ::swc_visit::Either<A, B>
+impl<A, B> Fold for ::swc_visit::Either<A, B>
 where
-    A: FoldAstPath,
-    B: FoldAstPath,
+    A: Fold,
+    B: Fold,
 {
     #[inline]
-    fn fold_accessibility(
-        &mut self,
-        node: Accessibility,
-        __ast_path: &mut AstKindPath,
-    ) -> Accessibility {
+    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_accessibility(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_accessibility(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_accessibility(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_accessibility(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
+    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_array_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_array_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_array_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_array_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
+    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_array_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_array_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_array_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_array_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
+    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_arrow_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_arrow_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_arrow_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_arrow_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
+    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_assign_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_assign_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_assign_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_assign_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
+    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_assign_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_assign_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_assign_op(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_assign_op(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
+    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_assign_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_assign_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_assign_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_assign_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_assign_pat_prop(
-        &mut self,
-        node: AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignPatProp {
+    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_assign_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_assign_pat_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_assign_pat_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_assign_pat_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
+    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_assign_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_assign_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_assign_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_assign_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_assign_target(
-        &mut self,
-        node: AssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTarget {
+    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_assign_target(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_assign_target(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_assign_target(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_assign_target(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_assign_target_pat(
-        &mut self,
-        node: AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTargetPat {
+    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_assign_target_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_assign_target_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_assign_target_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_assign_target_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_atom(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_auto_accessor(
-        &mut self,
-        node: AutoAccessor,
-        __ast_path: &mut AstKindPath,
-    ) -> AutoAccessor {
+    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_auto_accessor(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_auto_accessor(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_auto_accessor(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_auto_accessor(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
+    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_await_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_await_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_await_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_await_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
+    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_big_int(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_big_int(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_big_int(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_big_int(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_big_int_value(
-        &mut self,
-        node: BigIntValue,
-        __ast_path: &mut AstKindPath,
-    ) -> BigIntValue {
+    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_big_int_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_big_int_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_big_int_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_big_int_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
+    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_bin_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_bin_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_bin_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_bin_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
+    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_binary_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_binary_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_binary_op(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_binary_op(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_binding_ident(
-        &mut self,
-        node: BindingIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> BindingIdent {
+    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_binding_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_binding_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_binding_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_binding_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
+    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_block_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_block_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_block_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_block_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(
-        &mut self,
-        node: BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> BlockStmtOrExpr {
+    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_block_stmt_or_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_block_stmt_or_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_block_stmt_or_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_block_stmt_or_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
+    fn fold_bool(&mut self, node: Bool) -> Bool {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_bool(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_bool(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_bool(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_bool(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
+    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_break_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_break_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_break_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_break_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
+    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_call_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_call_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_call_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_call_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
+    fn fold_callee(&mut self, node: Callee) -> Callee {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_callee(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_callee(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_callee(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_callee(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_catch_clause(
-        &mut self,
-        node: CatchClause,
-        __ast_path: &mut AstKindPath,
-    ) -> CatchClause {
+    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_catch_clause(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_catch_clause(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_catch_clause(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_catch_clause(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
+    fn fold_class(&mut self, node: Class) -> Class {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_class(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_class(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_class(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
+    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_class_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_class_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_class_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
+    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_class_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_class_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_class_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class_member(
-        &mut self,
-        node: ClassMember,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMember {
+    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_class_member(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_class_member(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_class_member(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class_member(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class_members(
-        &mut self,
-        node: Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ClassMember> {
+    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_class_members(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_class_members(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_class_members(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class_members(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class_method(
-        &mut self,
-        node: ClassMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMethod {
+    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_class_method(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_class_method(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_class_method(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class_method(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
+    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_class_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_class_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_class_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_class_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_computed_prop_name(
-        &mut self,
-        node: ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) -> ComputedPropName {
+    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_computed_prop_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_computed_prop_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_computed_prop_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_computed_prop_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
+    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_cond_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_cond_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_cond_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_cond_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
+    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_constructor(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_constructor(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_constructor(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_constructor(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_continue_stmt(
-        &mut self,
-        node: ContinueStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> ContinueStmt {
+    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_continue_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_continue_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_continue_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_continue_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_debugger_stmt(
-        &mut self,
-        node: DebuggerStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DebuggerStmt {
+    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_debugger_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_debugger_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_debugger_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_debugger_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
+    fn fold_decl(&mut self, node: Decl) -> Decl {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_decl(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_decl(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
+    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_decorator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_decorator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_decorator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_decorator(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_decorators(
-        &mut self,
-        node: Vec<Decorator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Decorator> {
+    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_decorators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_decorators(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_decorators(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_decorators(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_default_decl(
-        &mut self,
-        node: DefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> DefaultDecl {
+    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_default_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_default_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_default_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_default_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_do_while_stmt(
-        &mut self,
-        node: DoWhileStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DoWhileStmt {
+    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_do_while_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_do_while_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_do_while_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_do_while_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
+    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_empty_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_empty_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_empty_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_empty_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
+    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_es_version(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_es_version(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_es_version(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_es_version(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
+    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_all(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_all(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_all(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_all(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
+    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_export_default_decl(
-        &mut self,
-        node: ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultDecl {
+    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_default_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_default_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_default_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_default_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_export_default_expr(
-        &mut self,
-        node: ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultExpr {
+    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_default_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_default_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_default_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_default_expr(visitor, node),
         }
     }
 
@@ -117827,31 +96837,18 @@ where
     fn fold_export_default_specifier(
         &mut self,
         node: ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportDefaultSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_default_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_default_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_default_specifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_default_specifier(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_export_named_specifier(
-        &mut self,
-        node: ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportNamedSpecifier {
+    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_named_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_named_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_named_specifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_named_specifier(visitor, node),
         }
     }
 
@@ -117859,257 +96856,174 @@ where
     fn fold_export_namespace_specifier(
         &mut self,
         node: ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportNamespaceSpecifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_namespace_specifier(visitor, node, __ast_path)
+                Fold::fold_export_namespace_specifier(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_namespace_specifier(visitor, node, __ast_path)
+                Fold::fold_export_namespace_specifier(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_export_specifier(
-        &mut self,
-        node: ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportSpecifier {
+    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_specifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_specifier(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_export_specifiers(
-        &mut self,
-        node: Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExportSpecifier> {
+    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_export_specifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_export_specifiers(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_export_specifiers(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_export_specifiers(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
+    fn fold_expr(&mut self, node: Expr) -> Expr {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_expr(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_expr(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_expr_or_spread(
-        &mut self,
-        node: ExprOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> ExprOrSpread {
+    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_expr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_expr_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_expr_or_spread(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_expr_or_spread(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_expr_or_spreads(
-        &mut self,
-        node: Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExprOrSpread> {
+    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_expr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_expr_or_spreads(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_expr_or_spreads(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_expr_or_spreads(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
+    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_expr_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_expr_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_expr_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_expr_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_exprs(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_exprs(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_exprs(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_exprs(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
+    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_fn_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_fn_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_fn_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_fn_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
+    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_fn_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_fn_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_fn_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_fn_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
+    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_for_head(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_for_head(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_for_head(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_for_head(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
+    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_for_in_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_for_in_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_for_in_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_for_in_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_for_of_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_for_of_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_for_of_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_for_of_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
+    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_for_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_for_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_for_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_for_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+    fn fold_function(&mut self, node: Function) -> Function {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_function(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_function(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_function(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_function(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
+    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_getter_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_getter_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_getter_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_getter_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+    fn fold_ident(&mut self, node: Ident) -> Ident {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
+    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ident_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ident_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ident_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ident_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
+    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_if_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_if_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_if_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_if_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
+    fn fold_import(&mut self, node: Import) -> Import {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_import(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
+    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_decl(visitor, node),
         }
     }
 
@@ -118117,79 +97031,42 @@ where
     fn fold_import_default_specifier(
         &mut self,
         node: ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportDefaultSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_default_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_default_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_default_specifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_default_specifier(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_named_specifier(
-        &mut self,
-        node: ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportNamedSpecifier {
+    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_named_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_named_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_named_specifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_named_specifier(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_phase(
-        &mut self,
-        node: ImportPhase,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPhase {
+    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_phase(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_phase(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_phase(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_phase(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_specifier(
-        &mut self,
-        node: ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportSpecifier {
+    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_specifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_specifier(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_specifiers(
-        &mut self,
-        node: Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportSpecifier> {
+    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_specifiers(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_specifiers(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_specifiers(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_specifiers(visitor, node),
         }
     }
 
@@ -118197,855 +97074,482 @@ where
     fn fold_import_star_as_specifier(
         &mut self,
         node: ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportStarAsSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_star_as_specifier(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_star_as_specifier(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_star_as_specifier(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_star_as_specifier(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
+    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_with(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_with(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_with(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_with(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_with_item(
-        &mut self,
-        node: ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportWithItem {
+    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_with_item(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_with_item(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_with_item(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_with_item(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_import_with_items(
-        &mut self,
-        node: Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportWithItem> {
+    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_import_with_items(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_import_with_items(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_import_with_items(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_import_with_items(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
+    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_invalid(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_invalid(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_invalid(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_invalid(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
+    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_attr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_attr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_name(
-        &mut self,
-        node: JSXAttrName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrName {
+    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_attr_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_attr_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(
-        &mut self,
-        node: JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrOrSpread {
+    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_attr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_attr_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_or_spread(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_or_spread(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(
-        &mut self,
-        node: Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXAttrOrSpread> {
+    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_attr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_attr_or_spreads(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_or_spreads(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_or_spreads(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_value(
-        &mut self,
-        node: JSXAttrValue,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrValue {
+    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_attr_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_attr_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_attr_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_attr_value(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_element(
-        &mut self,
-        node: JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingElement {
+    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_closing_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_closing_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_closing_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_closing_element(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(
-        &mut self,
-        node: JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingFragment {
+    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_closing_fragment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_closing_fragment(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_closing_fragment(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_closing_fragment(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
+    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_element_child(
-        &mut self,
-        node: JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementChild {
+    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_element_child(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_element_child(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element_child(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element_child(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_element_childs(
-        &mut self,
-        node: Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXElementChild> {
+    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_element_childs(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_element_childs(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element_childs(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element_childs(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_element_name(
-        &mut self,
-        node: JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementName {
+    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_element_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_element_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_element_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_element_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(
-        &mut self,
-        node: JSXEmptyExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXEmptyExpr {
+    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_empty_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_empty_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_empty_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_empty_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
+    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_expr_container(
-        &mut self,
-        node: JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXExprContainer {
+    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_expr_container(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_expr_container(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_expr_container(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_expr_container(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_fragment(
-        &mut self,
-        node: JSXFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXFragment {
+    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_fragment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_fragment(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_fragment(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_fragment(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_member_expr(
-        &mut self,
-        node: JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXMemberExpr {
+    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_member_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_member_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_member_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_member_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(
-        &mut self,
-        node: JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXNamespacedName {
+    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_namespaced_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_namespaced_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_namespaced_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_namespaced_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
+    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_object(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_object(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_object(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_object(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_element(
-        &mut self,
-        node: JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningElement {
+    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_opening_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_opening_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_opening_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_opening_element(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(
-        &mut self,
-        node: JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningFragment {
+    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_opening_fragment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_opening_fragment(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_opening_fragment(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_opening_fragment(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_spread_child(
-        &mut self,
-        node: JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXSpreadChild {
+    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_spread_child(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_spread_child(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_spread_child(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_spread_child(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_jsx_text(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_jsx_text(visitor, node, __ast_path)
-            }
+    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
+        match self {
+            swc_visit::Either::Left(visitor) => Fold::fold_jsx_text(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_jsx_text(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
+    fn fold_key(&mut self, node: Key) -> Key {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_key(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_key(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_key(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_key(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(
-        &mut self,
-        node: KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValuePatProp {
+    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_key_value_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_key_value_pat_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_key_value_pat_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_key_value_pat_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_key_value_prop(
-        &mut self,
-        node: KeyValueProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValueProp {
+    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_key_value_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_key_value_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_key_value_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_key_value_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_labeled_stmt(
-        &mut self,
-        node: LabeledStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> LabeledStmt {
+    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_labeled_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_labeled_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_labeled_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_labeled_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
+    fn fold_lit(&mut self, node: Lit) -> Lit {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_lit(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_lit(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
+    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_member_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_member_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_member_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_member_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
+    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_member_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_member_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_member_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_member_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_meta_prop_expr(
-        &mut self,
-        node: MetaPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropExpr {
+    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_meta_prop_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_meta_prop_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_meta_prop_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_meta_prop_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_meta_prop_kind(
-        &mut self,
-        node: MetaPropKind,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropKind {
+    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_meta_prop_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_meta_prop_kind(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_meta_prop_kind(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_meta_prop_kind(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
+    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_method_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_method_kind(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_method_kind(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_method_kind(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
+    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_method_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_method_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_method_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_method_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
+    fn fold_module(&mut self, node: Module) -> Module {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_module(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_module(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_module(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_module(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
+    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_module_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_module_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_module_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_module_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_module_export_name(
-        &mut self,
-        node: ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) -> ModuleExportName {
+    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_module_export_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_module_export_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_module_export_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_module_export_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
+    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_module_item(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_module_item(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_module_item(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_module_item(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_module_items(
-        &mut self,
-        node: Vec<ModuleItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ModuleItem> {
+    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_module_items(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_module_items(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_module_items(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_module_items(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_named_export(
-        &mut self,
-        node: NamedExport,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedExport {
+    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_named_export(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_named_export(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_named_export(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_named_export(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
+    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_new_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_new_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_new_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_new_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
+    fn fold_null(&mut self, node: Null) -> Null {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_null(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_null(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_null(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_null(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+    fn fold_number(&mut self, node: Number) -> Number {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_number(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_number(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_number(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_number(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
+    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_object_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_object_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_object_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_object_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
+    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_object_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_object_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_object_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_object_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_object_pat_prop(
-        &mut self,
-        node: ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ObjectPatProp {
+    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_object_pat_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_object_pat_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_object_pat_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_object_pat_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_object_pat_props(
-        &mut self,
-        node: Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ObjectPatProp> {
+    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_object_pat_props(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_object_pat_props(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_object_pat_props(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_object_pat_props(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_accessibility(
-        &mut self,
-        node: Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Accessibility> {
+    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_accessibility(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_accessibility(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_accessibility(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_accessibility(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_atom(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_atom(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_block_stmt(
-        &mut self,
-        node: Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<BlockStmt> {
+    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_block_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_block_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_block_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_block_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
+    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_call(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_call(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_call(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_call(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_catch_clause(
-        &mut self,
-        node: Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<CatchClause> {
+    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_catch_clause(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_catch_clause(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_catch_clause(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_catch_clause(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_chain_base(
-        &mut self,
-        node: OptChainBase,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainBase {
+    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_chain_base(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_chain_base(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_chain_base(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_chain_base(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_chain_expr(
-        &mut self,
-        node: OptChainExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainExpr {
+    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_chain_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_chain_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_chain_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_chain_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_expr(
-        &mut self,
-        node: Option<Box<Expr>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Expr>> {
+    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(
-        &mut self,
-        node: Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ExprOrSpread> {
+    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_expr_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_expr_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_expr_or_spread(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_expr_or_spread(visitor, node),
         }
     }
 
@@ -119053,47 +97557,26 @@ where
     fn fold_opt_expr_or_spreads(
         &mut self,
         node: Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<ExprOrSpread>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_expr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_expr_or_spreads(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_expr_or_spreads(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_expr_or_spreads(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(
-        &mut self,
-        node: Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<JSXAttrValue> {
+    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_jsx_attr_value(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_jsx_attr_value(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_jsx_attr_value(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_jsx_attr_value(visitor, node),
         }
     }
 
@@ -119101,15 +97584,10 @@ where
     fn fold_opt_jsx_closing_element(
         &mut self,
         node: Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<JSXClosingElement> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_jsx_closing_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_jsx_closing_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_jsx_closing_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_jsx_closing_element(visitor, node),
         }
     }
 
@@ -119117,123 +97595,66 @@ where
     fn fold_opt_module_export_name(
         &mut self,
         node: Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ModuleExportName> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_module_export_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_module_export_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_module_export_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_module_export_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_object_lit(
-        &mut self,
-        node: Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<ObjectLit>> {
+    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_object_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_object_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_object_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_object_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
+    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_span(
-        &mut self,
-        node: Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_common::Span> {
+    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_span(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_span(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_span(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_span(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_stmt(
-        &mut self,
-        node: Option<Box<Stmt>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Stmt>> {
+    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_str(
-        &mut self,
-        node: Option<Box<Str>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Str>> {
+    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_str(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_str(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_str(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_str(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(
-        &mut self,
-        node: Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TruePlusMinus> {
+    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_true_plus_minus(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_true_plus_minus(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_true_plus_minus(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_true_plus_minus(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(
-        &mut self,
-        node: Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TsEntityName> {
+    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ts_entity_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ts_entity_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_entity_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_entity_name(visitor, node),
         }
     }
 
@@ -119241,47 +97662,26 @@ where
     fn fold_opt_ts_namespace_body(
         &mut self,
         node: Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<TsNamespaceBody> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ts_namespace_body(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ts_namespace_body(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_namespace_body(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_namespace_body(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type(
-        &mut self,
-        node: Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsType>> {
+    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ts_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ts_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(
-        &mut self,
-        node: Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsTypeAnn>> {
+    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ts_type_ann(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ts_type_ann(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_type_ann(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_type_ann(visitor, node),
         }
     }
 
@@ -119289,15 +97689,10 @@ where
     fn fold_opt_ts_type_param_decl(
         &mut self,
         node: Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamDecl>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ts_type_param_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ts_type_param_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_ts_type_param_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_ts_type_param_decl(visitor, node),
         }
     }
 
@@ -119305,31 +97700,22 @@ where
     fn fold_opt_ts_type_param_instantiation(
         &mut self,
         node: Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamInstantiation>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_ts_type_param_instantiation(visitor, node, __ast_path)
+                Fold::fold_opt_ts_type_param_instantiation(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_ts_type_param_instantiation(visitor, node, __ast_path)
+                Fold::fold_opt_ts_type_param_instantiation(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(
-        &mut self,
-        node: Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<VarDeclOrExpr> {
+    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_var_decl_or_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_var_decl_or_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_var_decl_or_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_var_decl_or_expr(visitor, node),
         }
     }
 
@@ -119337,55 +97723,34 @@ where
     fn fold_opt_vec_expr_or_spreads(
         &mut self,
         node: Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<Option<ExprOrSpread>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_vec_expr_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_vec_expr_or_spreads(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_vec_expr_or_spreads(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_vec_expr_or_spreads(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_opt_vec_pats(
-        &mut self,
-        node: Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Option<Pat>> {
+    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_opt_vec_pats(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_opt_vec_pats(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_opt_vec_pats(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_opt_vec_pats(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
+    fn fold_param(&mut self, node: Param) -> Param {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_param(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_param(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_param(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_param(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(
-        &mut self,
-        node: ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ParamOrTsParamProp {
+    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_param_or_ts_param_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_param_or_ts_param_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_param_or_ts_param_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_param_or_ts_param_prop(visitor, node),
         }
     }
 
@@ -119393,391 +97758,258 @@ where
     fn fold_param_or_ts_param_props(
         &mut self,
         node: Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ParamOrTsParamProp> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_param_or_ts_param_props(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_param_or_ts_param_props(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_param_or_ts_param_props(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_param_or_ts_param_props(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
+    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_params(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_params(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_params(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_params(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
+    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_paren_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_paren_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_paren_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_paren_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
+    fn fold_pat(&mut self, node: Pat) -> Pat {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_pat(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_pat(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
+    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_pats(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_pats(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_pats(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_pats(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_private_method(
-        &mut self,
-        node: PrivateMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateMethod {
+    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_private_method(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_private_method(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_private_method(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_private_method(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_private_name(
-        &mut self,
-        node: PrivateName,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateName {
+    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_private_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_private_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_private_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_private_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_private_prop(
-        &mut self,
-        node: PrivateProp,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateProp {
+    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_private_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_private_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_private_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_private_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
+    fn fold_program(&mut self, node: Program) -> Program {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_program(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_program(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_program(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_program(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
+    fn fold_prop(&mut self, node: Prop) -> Prop {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_prop(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_prop(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
+    fn fold_prop_name(&mut self, node: PropName) -> PropName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_prop_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_prop_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_prop_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_prop_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_prop_or_spread(
-        &mut self,
-        node: PropOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> PropOrSpread {
+    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_prop_or_spread(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_prop_or_spread(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_prop_or_spread(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_prop_or_spread(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_prop_or_spreads(
-        &mut self,
-        node: Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PropOrSpread> {
+    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_prop_or_spreads(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_prop_or_spreads(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_prop_or_spreads(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_prop_or_spreads(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
+    fn fold_regex(&mut self, node: Regex) -> Regex {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_regex(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_regex(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_regex(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_regex(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
+    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_rest_pat(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_rest_pat(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_rest_pat(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_rest_pat(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
+    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_return_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_return_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_return_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_return_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
+    fn fold_script(&mut self, node: Script) -> Script {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_script(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_script(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_script(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_script(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
+    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_seq_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_seq_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_seq_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_seq_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
+    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_setter_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_setter_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_setter_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_setter_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_simple_assign_target(
-        &mut self,
-        node: SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleAssignTarget {
+    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_simple_assign_target(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_simple_assign_target(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_simple_assign_target(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_simple_assign_target(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_span(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_span(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_spread_element(
-        &mut self,
-        node: SpreadElement,
-        __ast_path: &mut AstKindPath,
-    ) -> SpreadElement {
+    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_spread_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_spread_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_spread_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_spread_element(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_static_block(
-        &mut self,
-        node: StaticBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> StaticBlock {
+    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_static_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_static_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_static_block(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_static_block(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
+    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_stmt(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_stmt(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
+    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_stmts(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_stmts(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_stmts(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_stmts(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+    fn fold_str(&mut self, node: Str) -> Str {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_str(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_str(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
+    fn fold_super(&mut self, node: Super) -> Super {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_super(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_super(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_super(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_super(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
+    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_super_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_super_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_super_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_super_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_super_prop_expr(
-        &mut self,
-        node: SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> SuperPropExpr {
+    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_super_prop_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_super_prop_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_super_prop_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_super_prop_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
+    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_switch_case(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_switch_case(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_switch_case(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_switch_case(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_switch_cases(
-        &mut self,
-        node: Vec<SwitchCase>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SwitchCase> {
+    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_switch_cases(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_switch_cases(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_switch_cases(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_switch_cases(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
+    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_switch_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_switch_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_switch_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_switch_stmt(visitor, node),
         }
     }
 
@@ -119785,191 +98017,114 @@ where
     fn fold_syntax_context(
         &mut self,
         node: swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
     ) -> swc_common::SyntaxContext {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_syntax_context(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_syntax_context(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_syntax_context(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_syntax_context(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_tagged_tpl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_tagged_tpl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_tagged_tpl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_tagged_tpl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
+    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_this_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_this_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_this_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_this_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
+    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_throw_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_throw_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_throw_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_throw_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
+    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_tpl(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => FoldAstPath::fold_tpl(visitor, node, __ast_path),
+            swc_visit::Either::Left(visitor) => Fold::fold_tpl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_tpl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
+    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_tpl_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_tpl_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_tpl_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_tpl_element(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_tpl_elements(
-        &mut self,
-        node: Vec<TplElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TplElement> {
+    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_tpl_elements(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_tpl_elements(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_tpl_elements(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_tpl_elements(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_true_plus_minus(
-        &mut self,
-        node: TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) -> TruePlusMinus {
+    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_true_plus_minus(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_true_plus_minus(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_true_plus_minus(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_true_plus_minus(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
+    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_try_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_try_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_try_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_try_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_array_type(
-        &mut self,
-        node: TsArrayType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsArrayType {
+    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_array_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_array_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_array_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_array_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_as_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_as_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_as_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_as_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(
-        &mut self,
-        node: TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsCallSignatureDecl {
+    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_call_signature_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_call_signature_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_call_signature_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_call_signature_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_conditional_type(
-        &mut self,
-        node: TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConditionalType {
+    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_conditional_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_conditional_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_conditional_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_conditional_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_const_assertion(
-        &mut self,
-        node: TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstAssertion {
+    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_const_assertion(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_const_assertion(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_const_assertion(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_const_assertion(visitor, node),
         }
     }
 
@@ -119977,139 +98132,78 @@ where
     fn fold_ts_construct_signature_decl(
         &mut self,
         node: TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsConstructSignatureDecl {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_construct_signature_decl(visitor, node, __ast_path)
+                Fold::fold_ts_construct_signature_decl(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_construct_signature_decl(visitor, node, __ast_path)
+                Fold::fold_ts_construct_signature_decl(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_constructor_type(
-        &mut self,
-        node: TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstructorType {
+    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_constructor_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_constructor_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_constructor_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_constructor_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_entity_name(
-        &mut self,
-        node: TsEntityName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEntityName {
+    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_entity_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_entity_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_entity_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_entity_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_enum_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_enum_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member(
-        &mut self,
-        node: TsEnumMember,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMember {
+    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_enum_member(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_enum_member(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_member(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_member(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(
-        &mut self,
-        node: TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMemberId {
+    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_enum_member_id(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_enum_member_id(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_member_id(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_member_id(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_enum_members(
-        &mut self,
-        node: Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsEnumMember> {
+    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_enum_members(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_enum_members(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_enum_members(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_enum_members(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_export_assignment(
-        &mut self,
-        node: TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExportAssignment {
+    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_export_assignment(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_export_assignment(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_export_assignment(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_export_assignment(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(
-        &mut self,
-        node: TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExprWithTypeArgs {
+    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_expr_with_type_args(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_expr_with_type_args(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_expr_with_type_args(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_expr_with_type_args(visitor, node),
         }
     }
 
@@ -120117,31 +98211,18 @@ where
     fn fold_ts_expr_with_type_argss(
         &mut self,
         node: Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<TsExprWithTypeArgs> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_expr_with_type_argss(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_expr_with_type_argss(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_expr_with_type_argss(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_expr_with_type_argss(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(
-        &mut self,
-        node: TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExternalModuleRef {
+    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_external_module_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_external_module_ref(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_external_module_ref(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_external_module_ref(visitor, node),
         }
     }
 
@@ -120149,397 +98230,212 @@ where
     fn fold_ts_fn_or_constructor_type(
         &mut self,
         node: TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
     ) -> TsFnOrConstructorType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_fn_or_constructor_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_or_constructor_type(visitor, node),
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_fn_or_constructor_type(visitor, node, __ast_path)
+                Fold::fold_ts_fn_or_constructor_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
+    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_fn_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_fn_param(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_param(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_fn_param(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_fn_params(
-        &mut self,
-        node: Vec<TsFnParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsFnParam> {
+    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_fn_params(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_fn_params(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_params(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_fn_params(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
+    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_fn_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_fn_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_fn_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_fn_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_getter_signature(
-        &mut self,
-        node: TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsGetterSignature {
+    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_getter_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_getter_signature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_getter_signature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_getter_signature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(
-        &mut self,
-        node: TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportEqualsDecl {
+    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_import_equals_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_import_equals_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_import_equals_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_import_equals_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_import_type(
-        &mut self,
-        node: TsImportType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportType {
+    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_import_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_import_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_import_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_import_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_index_signature(
-        &mut self,
-        node: TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexSignature {
+    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_index_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_index_signature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_index_signature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_index_signature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(
-        &mut self,
-        node: TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexedAccessType {
+    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_indexed_access_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_indexed_access_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_indexed_access_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_indexed_access_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_infer_type(
-        &mut self,
-        node: TsInferType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInferType {
+    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_infer_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_infer_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_infer_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_infer_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_instantiation(
-        &mut self,
-        node: TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInstantiation {
+    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_instantiation(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_instantiation(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_instantiation(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_instantiation(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_interface_body(
-        &mut self,
-        node: TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceBody {
+    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_interface_body(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_interface_body(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_interface_body(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_interface_body(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_interface_decl(
-        &mut self,
-        node: TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceDecl {
+    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_interface_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_interface_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_interface_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_interface_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_intersection_type(
-        &mut self,
-        node: TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIntersectionType {
+    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_intersection_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_intersection_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_intersection_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_intersection_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type(
-        &mut self,
-        node: TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordType {
+    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_keyword_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_keyword_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_keyword_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_keyword_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(
-        &mut self,
-        node: TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordTypeKind {
+    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_keyword_type_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_keyword_type_kind(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_keyword_type_kind(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_keyword_type_kind(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
+    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
         match self {
-            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ts_lit(visitor, node, __ast_path),
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
+    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_lit_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_lit_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_lit_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_lit_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_mapped_type(
-        &mut self,
-        node: TsMappedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMappedType {
+    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_mapped_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_mapped_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_mapped_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_mapped_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_method_signature(
-        &mut self,
-        node: TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMethodSignature {
+    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_method_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_method_signature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_method_signature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_method_signature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_module_block(
-        &mut self,
-        node: TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleBlock {
+    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_module_block(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_module_block(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_block(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_block(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_module_decl(
-        &mut self,
-        node: TsModuleDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleDecl {
+    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_module_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_module_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_module_name(
-        &mut self,
-        node: TsModuleName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleName {
+    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_module_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_module_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_module_ref(
-        &mut self,
-        node: TsModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleRef {
+    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_module_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_module_ref(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_module_ref(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_module_ref(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_body(
-        &mut self,
-        node: TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceBody {
+    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_namespace_body(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_namespace_body(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_namespace_body(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_namespace_body(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(
-        &mut self,
-        node: TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceDecl {
+    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_namespace_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_namespace_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_namespace_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_namespace_decl(visitor, node),
         }
     }
 
@@ -120547,427 +98443,226 @@ where
     fn fold_ts_namespace_export_decl(
         &mut self,
         node: TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsNamespaceExportDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_namespace_export_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_namespace_export_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_namespace_export_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_namespace_export_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(
-        &mut self,
-        node: TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNonNullExpr {
+    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_non_null_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_non_null_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_non_null_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_non_null_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_optional_type(
-        &mut self,
-        node: TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsOptionalType {
+    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_optional_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_optional_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_optional_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_optional_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop(
-        &mut self,
-        node: TsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamProp {
+    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_param_prop(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_param_prop(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_param_prop(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_param_prop(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(
-        &mut self,
-        node: TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamPropParam {
+    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_param_prop_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_param_prop_param(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_param_prop_param(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_param_prop_param(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(
-        &mut self,
-        node: TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParenthesizedType {
+    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_parenthesized_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_parenthesized_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_parenthesized_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_parenthesized_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_property_signature(
-        &mut self,
-        node: TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsPropertySignature {
+    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_property_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_property_signature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_property_signature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_property_signature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_qualified_name(
-        &mut self,
-        node: TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsQualifiedName {
+    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_qualified_name(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_qualified_name(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_qualified_name(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_qualified_name(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
+    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_rest_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_rest_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_rest_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_rest_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(
-        &mut self,
-        node: TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSatisfiesExpr {
+    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_satisfies_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_satisfies_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_satisfies_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_satisfies_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_setter_signature(
-        &mut self,
-        node: TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSetterSignature {
+    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_setter_signature(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_setter_signature(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_setter_signature(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_setter_signature(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
+    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_this_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_this_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_this_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_this_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(
-        &mut self,
-        node: TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> TsThisTypeOrIdent {
+    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_this_type_or_ident(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_this_type_or_ident(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_this_type_or_ident(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_this_type_or_ident(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(
-        &mut self,
-        node: TsTplLitType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTplLitType {
+    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_tpl_lit_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_tpl_lit_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_tpl_lit_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_tpl_lit_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_element(
-        &mut self,
-        node: TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleElement {
+    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_tuple_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_tuple_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_tuple_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_tuple_element(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(
-        &mut self,
-        node: Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTupleElement> {
+    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_tuple_elements(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_tuple_elements(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_tuple_elements(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_tuple_elements(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_type(
-        &mut self,
-        node: TsTupleType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleType {
+    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_tuple_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_tuple_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_tuple_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_tuple_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
+    fn fold_ts_type(&mut self, node: TsType) -> TsType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(
-        &mut self,
-        node: TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAliasDecl {
+    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_alias_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_alias_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_alias_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_alias_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_ann(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_ann(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_ann(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_ann(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_assertion(
-        &mut self,
-        node: TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAssertion {
+    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_assertion(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_assertion(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_assertion(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_assertion(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_element(
-        &mut self,
-        node: TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeElement {
+    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_element(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_element(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_element(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_element(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_elements(
-        &mut self,
-        node: Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeElement> {
+    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_elements(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_elements(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_elements(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_elements(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_lit(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_lit(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_lit(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_lit(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator(
-        &mut self,
-        node: TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperator {
+    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_operator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_operator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_operator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_operator(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(
-        &mut self,
-        node: TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperatorOp {
+    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_operator_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_operator_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_operator_op(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_operator_op(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_param(
-        &mut self,
-        node: TsTypeParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParam {
+    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_param(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_param(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_param(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_param(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(
-        &mut self,
-        node: TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParamDecl {
+    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_param_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_param_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_param_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_param_decl(visitor, node),
         }
     }
 
@@ -120975,107 +98670,62 @@ where
     fn fold_ts_type_param_instantiation(
         &mut self,
         node: TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
     ) -> TsTypeParamInstantiation {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_param_instantiation(visitor, node, __ast_path)
+                Fold::fold_ts_type_param_instantiation(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_param_instantiation(visitor, node, __ast_path)
+                Fold::fold_ts_type_param_instantiation(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_type_params(
-        &mut self,
-        node: Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeParam> {
+    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_params(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_params(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_params(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_params(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_predicate(
-        &mut self,
-        node: TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypePredicate {
+    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_predicate(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_predicate(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_predicate(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_predicate(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_query(
-        &mut self,
-        node: TsTypeQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQuery {
+    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_query(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_query(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_query(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_query(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(
-        &mut self,
-        node: TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQueryExpr {
+    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_query_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_query_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_query_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_query_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_type_ref(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_type_ref(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_type_ref(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_type_ref(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_ts_types(
-        &mut self,
-        node: Vec<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Box<TsType>> {
+    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_types(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_types(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_types(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_types(visitor, node),
         }
     }
 
@@ -121083,732 +98733,569 @@ where
     fn fold_ts_union_or_intersection_type(
         &mut self,
         node: TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
     ) -> TsUnionOrIntersectionType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_union_or_intersection_type(visitor, node, __ast_path)
+                Fold::fold_ts_union_or_intersection_type(visitor, node)
             }
             swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_union_or_intersection_type(visitor, node, __ast_path)
+                Fold::fold_ts_union_or_intersection_type(visitor, node)
             }
         }
     }
 
     #[inline]
-    fn fold_ts_union_type(
-        &mut self,
-        node: TsUnionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsUnionType {
+    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_ts_union_type(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_ts_union_type(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_ts_union_type(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_ts_union_type(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
+    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_unary_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_unary_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_unary_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_unary_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
+    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_unary_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_unary_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_unary_op(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_unary_op(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
+    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_update_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_update_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_update_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_update_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
+    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_update_op(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_update_op(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_update_op(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_update_op(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
+    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_using_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_using_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_using_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_using_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
+    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_var_decl(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_var_decl(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_var_decl(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_var_decl(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_var_decl_kind(
-        &mut self,
-        node: VarDeclKind,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclKind {
+    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_var_decl_kind(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_var_decl_kind(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_var_decl_kind(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_var_decl_kind(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(
-        &mut self,
-        node: VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclOrExpr {
+    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_var_decl_or_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_var_decl_or_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_var_decl_or_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_var_decl_or_expr(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_var_declarator(
-        &mut self,
-        node: VarDeclarator,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclarator {
+    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_var_declarator(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_var_declarator(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_var_declarator(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_var_declarator(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_var_declarators(
-        &mut self,
-        node: Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<VarDeclarator> {
+    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_var_declarators(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_var_declarators(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_var_declarators(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_var_declarators(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
+    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_while_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_while_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_while_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_while_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
+    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_with_stmt(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_with_stmt(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_with_stmt(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_with_stmt(visitor, node),
         }
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
+    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
         match self {
-            swc_visit::Either::Left(visitor) => {
-                FoldAstPath::fold_yield_expr(visitor, node, __ast_path)
-            }
-            swc_visit::Either::Right(visitor) => {
-                FoldAstPath::fold_yield_expr(visitor, node, __ast_path)
-            }
+            swc_visit::Either::Left(visitor) => Fold::fold_yield_expr(visitor, node),
+            swc_visit::Either::Right(visitor) => Fold::fold_yield_expr(visitor, node),
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> FoldAstPath for ::swc_visit::Optional<V>
+impl<V> Fold for ::swc_visit::Optional<V>
 where
-    V: FoldAstPath,
+    V: Fold,
 {
     #[inline]
-    fn fold_accessibility(
-        &mut self,
-        node: Accessibility,
-        __ast_path: &mut AstKindPath,
-    ) -> Accessibility {
+    fn fold_accessibility(&mut self, node: Accessibility) -> Accessibility {
         if self.enabled {
-            <V as FoldAstPath>::fold_accessibility(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_accessibility(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
+    fn fold_array_lit(&mut self, node: ArrayLit) -> ArrayLit {
         if self.enabled {
-            <V as FoldAstPath>::fold_array_lit(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_array_lit(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
+    fn fold_array_pat(&mut self, node: ArrayPat) -> ArrayPat {
         if self.enabled {
-            <V as FoldAstPath>::fold_array_pat(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_array_pat(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
+    fn fold_arrow_expr(&mut self, node: ArrowExpr) -> ArrowExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_arrow_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_arrow_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
+    fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_assign_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_assign_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
+    fn fold_assign_op(&mut self, node: AssignOp) -> AssignOp {
         if self.enabled {
-            <V as FoldAstPath>::fold_assign_op(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_assign_op(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
+    fn fold_assign_pat(&mut self, node: AssignPat) -> AssignPat {
         if self.enabled {
-            <V as FoldAstPath>::fold_assign_pat(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_assign_pat(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_assign_pat_prop(
-        &mut self,
-        node: AssignPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignPatProp {
+    fn fold_assign_pat_prop(&mut self, node: AssignPatProp) -> AssignPatProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_assign_pat_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_assign_pat_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
+    fn fold_assign_prop(&mut self, node: AssignProp) -> AssignProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_assign_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_assign_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_assign_target(
-        &mut self,
-        node: AssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTarget {
+    fn fold_assign_target(&mut self, node: AssignTarget) -> AssignTarget {
         if self.enabled {
-            <V as FoldAstPath>::fold_assign_target(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_assign_target(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_assign_target_pat(
-        &mut self,
-        node: AssignTargetPat,
-        __ast_path: &mut AstKindPath,
-    ) -> AssignTargetPat {
+    fn fold_assign_target_pat(&mut self, node: AssignTargetPat) -> AssignTargetPat {
         if self.enabled {
-            <V as FoldAstPath>::fold_assign_target_pat(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_assign_target_pat(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_atom(
-        &mut self,
-        node: swc_atoms::Atom,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_atoms::Atom {
+    fn fold_atom(&mut self, node: swc_atoms::Atom) -> swc_atoms::Atom {
         if self.enabled {
-            <V as FoldAstPath>::fold_atom(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_atom(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_auto_accessor(
-        &mut self,
-        node: AutoAccessor,
-        __ast_path: &mut AstKindPath,
-    ) -> AutoAccessor {
+    fn fold_auto_accessor(&mut self, node: AutoAccessor) -> AutoAccessor {
         if self.enabled {
-            <V as FoldAstPath>::fold_auto_accessor(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_auto_accessor(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
+    fn fold_await_expr(&mut self, node: AwaitExpr) -> AwaitExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_await_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_await_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
+    fn fold_big_int(&mut self, node: BigInt) -> BigInt {
         if self.enabled {
-            <V as FoldAstPath>::fold_big_int(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_big_int(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_big_int_value(
-        &mut self,
-        node: BigIntValue,
-        __ast_path: &mut AstKindPath,
-    ) -> BigIntValue {
+    fn fold_big_int_value(&mut self, node: BigIntValue) -> BigIntValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_big_int_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_big_int_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
+    fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_bin_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_bin_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
+    fn fold_binary_op(&mut self, node: BinaryOp) -> BinaryOp {
         if self.enabled {
-            <V as FoldAstPath>::fold_binary_op(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_binary_op(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_binding_ident(
-        &mut self,
-        node: BindingIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> BindingIdent {
+    fn fold_binding_ident(&mut self, node: BindingIdent) -> BindingIdent {
         if self.enabled {
-            <V as FoldAstPath>::fold_binding_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_binding_ident(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
+    fn fold_block_stmt(&mut self, node: BlockStmt) -> BlockStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_block_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_block_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_block_stmt_or_expr(
-        &mut self,
-        node: BlockStmtOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> BlockStmtOrExpr {
+    fn fold_block_stmt_or_expr(&mut self, node: BlockStmtOrExpr) -> BlockStmtOrExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_block_stmt_or_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_block_stmt_or_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
+    fn fold_bool(&mut self, node: Bool) -> Bool {
         if self.enabled {
-            <V as FoldAstPath>::fold_bool(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_bool(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
+    fn fold_break_stmt(&mut self, node: BreakStmt) -> BreakStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_break_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_break_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
+    fn fold_call_expr(&mut self, node: CallExpr) -> CallExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_call_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_call_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
+    fn fold_callee(&mut self, node: Callee) -> Callee {
         if self.enabled {
-            <V as FoldAstPath>::fold_callee(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_callee(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_catch_clause(
-        &mut self,
-        node: CatchClause,
-        __ast_path: &mut AstKindPath,
-    ) -> CatchClause {
+    fn fold_catch_clause(&mut self, node: CatchClause) -> CatchClause {
         if self.enabled {
-            <V as FoldAstPath>::fold_catch_clause(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_catch_clause(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
+    fn fold_class(&mut self, node: Class) -> Class {
         if self.enabled {
-            <V as FoldAstPath>::fold_class(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
+    fn fold_class_decl(&mut self, node: ClassDecl) -> ClassDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_class_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
+    fn fold_class_expr(&mut self, node: ClassExpr) -> ClassExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_class_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class_member(
-        &mut self,
-        node: ClassMember,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMember {
+    fn fold_class_member(&mut self, node: ClassMember) -> ClassMember {
         if self.enabled {
-            <V as FoldAstPath>::fold_class_member(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class_member(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class_members(
-        &mut self,
-        node: Vec<ClassMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ClassMember> {
+    fn fold_class_members(&mut self, node: Vec<ClassMember>) -> Vec<ClassMember> {
         if self.enabled {
-            <V as FoldAstPath>::fold_class_members(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class_members(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class_method(
-        &mut self,
-        node: ClassMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> ClassMethod {
+    fn fold_class_method(&mut self, node: ClassMethod) -> ClassMethod {
         if self.enabled {
-            <V as FoldAstPath>::fold_class_method(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class_method(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
+    fn fold_class_prop(&mut self, node: ClassProp) -> ClassProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_class_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_class_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_computed_prop_name(
-        &mut self,
-        node: ComputedPropName,
-        __ast_path: &mut AstKindPath,
-    ) -> ComputedPropName {
+    fn fold_computed_prop_name(&mut self, node: ComputedPropName) -> ComputedPropName {
         if self.enabled {
-            <V as FoldAstPath>::fold_computed_prop_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_computed_prop_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
+    fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_cond_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_cond_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
+    fn fold_constructor(&mut self, node: Constructor) -> Constructor {
         if self.enabled {
-            <V as FoldAstPath>::fold_constructor(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_constructor(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_continue_stmt(
-        &mut self,
-        node: ContinueStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> ContinueStmt {
+    fn fold_continue_stmt(&mut self, node: ContinueStmt) -> ContinueStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_continue_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_continue_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_debugger_stmt(
-        &mut self,
-        node: DebuggerStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DebuggerStmt {
+    fn fold_debugger_stmt(&mut self, node: DebuggerStmt) -> DebuggerStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_debugger_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_debugger_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
+    fn fold_decl(&mut self, node: Decl) -> Decl {
         if self.enabled {
-            <V as FoldAstPath>::fold_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
+    fn fold_decorator(&mut self, node: Decorator) -> Decorator {
         if self.enabled {
-            <V as FoldAstPath>::fold_decorator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_decorator(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_decorators(
-        &mut self,
-        node: Vec<Decorator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Decorator> {
+    fn fold_decorators(&mut self, node: Vec<Decorator>) -> Vec<Decorator> {
         if self.enabled {
-            <V as FoldAstPath>::fold_decorators(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_decorators(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_default_decl(
-        &mut self,
-        node: DefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> DefaultDecl {
+    fn fold_default_decl(&mut self, node: DefaultDecl) -> DefaultDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_default_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_default_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_do_while_stmt(
-        &mut self,
-        node: DoWhileStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> DoWhileStmt {
+    fn fold_do_while_stmt(&mut self, node: DoWhileStmt) -> DoWhileStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_do_while_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_do_while_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
+    fn fold_empty_stmt(&mut self, node: EmptyStmt) -> EmptyStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_empty_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_empty_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
+    fn fold_es_version(&mut self, node: EsVersion) -> EsVersion {
         if self.enabled {
-            <V as FoldAstPath>::fold_es_version(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_es_version(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
+    fn fold_export_all(&mut self, node: ExportAll) -> ExportAll {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_all(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_all(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
+    fn fold_export_decl(&mut self, node: ExportDecl) -> ExportDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_export_default_decl(
-        &mut self,
-        node: ExportDefaultDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultDecl {
+    fn fold_export_default_decl(&mut self, node: ExportDefaultDecl) -> ExportDefaultDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_default_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_default_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_export_default_expr(
-        &mut self,
-        node: ExportDefaultExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportDefaultExpr {
+    fn fold_export_default_expr(&mut self, node: ExportDefaultExpr) -> ExportDefaultExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_default_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_default_expr(&mut self.visitor, node)
         } else {
             node
         }
@@ -121818,23 +99305,18 @@ where
     fn fold_export_default_specifier(
         &mut self,
         node: ExportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportDefaultSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_default_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_default_specifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_export_named_specifier(
-        &mut self,
-        node: ExportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportNamedSpecifier {
+    fn fold_export_named_specifier(&mut self, node: ExportNamedSpecifier) -> ExportNamedSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_named_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_named_specifier(&mut self.visitor, node)
         } else {
             node
         }
@@ -121844,206 +99326,189 @@ where
     fn fold_export_namespace_specifier(
         &mut self,
         node: ExportNamespaceSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ExportNamespaceSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_namespace_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_namespace_specifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_export_specifier(
-        &mut self,
-        node: ExportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ExportSpecifier {
+    fn fold_export_specifier(&mut self, node: ExportSpecifier) -> ExportSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_specifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_export_specifiers(
-        &mut self,
-        node: Vec<ExportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExportSpecifier> {
+    fn fold_export_specifiers(&mut self, node: Vec<ExportSpecifier>) -> Vec<ExportSpecifier> {
         if self.enabled {
-            <V as FoldAstPath>::fold_export_specifiers(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_export_specifiers(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
+    fn fold_expr(&mut self, node: Expr) -> Expr {
         if self.enabled {
-            <V as FoldAstPath>::fold_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_expr_or_spread(
-        &mut self,
-        node: ExprOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> ExprOrSpread {
+    fn fold_expr_or_spread(&mut self, node: ExprOrSpread) -> ExprOrSpread {
         if self.enabled {
-            <V as FoldAstPath>::fold_expr_or_spread(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_expr_or_spread(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_expr_or_spreads(
-        &mut self,
-        node: Vec<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ExprOrSpread> {
+    fn fold_expr_or_spreads(&mut self, node: Vec<ExprOrSpread>) -> Vec<ExprOrSpread> {
         if self.enabled {
-            <V as FoldAstPath>::fold_expr_or_spreads(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_expr_or_spreads(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
+    fn fold_expr_stmt(&mut self, node: ExprStmt) -> ExprStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_expr_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_expr_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>) -> Vec<Box<Expr>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_exprs(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_exprs(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
+    fn fold_fn_decl(&mut self, node: FnDecl) -> FnDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_fn_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_fn_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
+    fn fold_fn_expr(&mut self, node: FnExpr) -> FnExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_fn_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_fn_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
+    fn fold_for_head(&mut self, node: ForHead) -> ForHead {
         if self.enabled {
-            <V as FoldAstPath>::fold_for_head(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_for_head(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
+    fn fold_for_in_stmt(&mut self, node: ForInStmt) -> ForInStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_for_in_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_for_in_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt) -> ForOfStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_for_of_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_for_of_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
+    fn fold_for_stmt(&mut self, node: ForStmt) -> ForStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_for_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_for_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+    fn fold_function(&mut self, node: Function) -> Function {
         if self.enabled {
-            <V as FoldAstPath>::fold_function(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_function(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
+    fn fold_getter_prop(&mut self, node: GetterProp) -> GetterProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_getter_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_getter_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+    fn fold_ident(&mut self, node: Ident) -> Ident {
         if self.enabled {
-            <V as FoldAstPath>::fold_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ident(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
+    fn fold_ident_name(&mut self, node: IdentName) -> IdentName {
         if self.enabled {
-            <V as FoldAstPath>::fold_ident_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ident_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
+    fn fold_if_stmt(&mut self, node: IfStmt) -> IfStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_if_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_if_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
+    fn fold_import(&mut self, node: Import) -> Import {
         if self.enabled {
-            <V as FoldAstPath>::fold_import(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
+    fn fold_import_decl(&mut self, node: ImportDecl) -> ImportDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_decl(&mut self.visitor, node)
         } else {
             node
         }
@@ -122053,62 +99518,45 @@ where
     fn fold_import_default_specifier(
         &mut self,
         node: ImportDefaultSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportDefaultSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_default_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_default_specifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_named_specifier(
-        &mut self,
-        node: ImportNamedSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportNamedSpecifier {
+    fn fold_import_named_specifier(&mut self, node: ImportNamedSpecifier) -> ImportNamedSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_named_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_named_specifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_phase(
-        &mut self,
-        node: ImportPhase,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportPhase {
+    fn fold_import_phase(&mut self, node: ImportPhase) -> ImportPhase {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_phase(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_phase(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_specifier(
-        &mut self,
-        node: ImportSpecifier,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportSpecifier {
+    fn fold_import_specifier(&mut self, node: ImportSpecifier) -> ImportSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_specifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_specifiers(
-        &mut self,
-        node: Vec<ImportSpecifier>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportSpecifier> {
+    fn fold_import_specifiers(&mut self, node: Vec<ImportSpecifier>) -> Vec<ImportSpecifier> {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_specifiers(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_specifiers(&mut self.visitor, node)
         } else {
             node
         }
@@ -122118,689 +99566,540 @@ where
     fn fold_import_star_as_specifier(
         &mut self,
         node: ImportStarAsSpecifier,
-        __ast_path: &mut AstKindPath,
     ) -> ImportStarAsSpecifier {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_star_as_specifier(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_star_as_specifier(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
+    fn fold_import_with(&mut self, node: ImportWith) -> ImportWith {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_with(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_with(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_with_item(
-        &mut self,
-        node: ImportWithItem,
-        __ast_path: &mut AstKindPath,
-    ) -> ImportWithItem {
+    fn fold_import_with_item(&mut self, node: ImportWithItem) -> ImportWithItem {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_with_item(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_with_item(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_import_with_items(
-        &mut self,
-        node: Vec<ImportWithItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ImportWithItem> {
+    fn fold_import_with_items(&mut self, node: Vec<ImportWithItem>) -> Vec<ImportWithItem> {
         if self.enabled {
-            <V as FoldAstPath>::fold_import_with_items(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_import_with_items(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
+    fn fold_invalid(&mut self, node: Invalid) -> Invalid {
         if self.enabled {
-            <V as FoldAstPath>::fold_invalid(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_invalid(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
+    fn fold_jsx_attr(&mut self, node: JSXAttr) -> JSXAttr {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_attr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_attr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_name(
-        &mut self,
-        node: JSXAttrName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrName {
+    fn fold_jsx_attr_name(&mut self, node: JSXAttrName) -> JSXAttrName {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_attr_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_attr_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spread(
-        &mut self,
-        node: JSXAttrOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrOrSpread {
+    fn fold_jsx_attr_or_spread(&mut self, node: JSXAttrOrSpread) -> JSXAttrOrSpread {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_attr_or_spread(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_attr_or_spread(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_or_spreads(
-        &mut self,
-        node: Vec<JSXAttrOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXAttrOrSpread> {
+    fn fold_jsx_attr_or_spreads(&mut self, node: Vec<JSXAttrOrSpread>) -> Vec<JSXAttrOrSpread> {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_attr_or_spreads(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_attr_or_spreads(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_attr_value(
-        &mut self,
-        node: JSXAttrValue,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXAttrValue {
+    fn fold_jsx_attr_value(&mut self, node: JSXAttrValue) -> JSXAttrValue {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_attr_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_attr_value(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_element(
-        &mut self,
-        node: JSXClosingElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingElement {
+    fn fold_jsx_closing_element(&mut self, node: JSXClosingElement) -> JSXClosingElement {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_closing_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_closing_element(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_closing_fragment(
-        &mut self,
-        node: JSXClosingFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXClosingFragment {
+    fn fold_jsx_closing_fragment(&mut self, node: JSXClosingFragment) -> JSXClosingFragment {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_closing_fragment(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_closing_fragment(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
+    fn fold_jsx_element(&mut self, node: JSXElement) -> JSXElement {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_element(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_element_child(
-        &mut self,
-        node: JSXElementChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementChild {
+    fn fold_jsx_element_child(&mut self, node: JSXElementChild) -> JSXElementChild {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_element_child(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_element_child(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_element_childs(
-        &mut self,
-        node: Vec<JSXElementChild>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<JSXElementChild> {
+    fn fold_jsx_element_childs(&mut self, node: Vec<JSXElementChild>) -> Vec<JSXElementChild> {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_element_childs(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_element_childs(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_element_name(
-        &mut self,
-        node: JSXElementName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXElementName {
+    fn fold_jsx_element_name(&mut self, node: JSXElementName) -> JSXElementName {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_element_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_element_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_empty_expr(
-        &mut self,
-        node: JSXEmptyExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXEmptyExpr {
+    fn fold_jsx_empty_expr(&mut self, node: JSXEmptyExpr) -> JSXEmptyExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_empty_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_empty_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
+    fn fold_jsx_expr(&mut self, node: JSXExpr) -> JSXExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_expr_container(
-        &mut self,
-        node: JSXExprContainer,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXExprContainer {
+    fn fold_jsx_expr_container(&mut self, node: JSXExprContainer) -> JSXExprContainer {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_expr_container(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_expr_container(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_fragment(
-        &mut self,
-        node: JSXFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXFragment {
+    fn fold_jsx_fragment(&mut self, node: JSXFragment) -> JSXFragment {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_fragment(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_fragment(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_member_expr(
-        &mut self,
-        node: JSXMemberExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXMemberExpr {
+    fn fold_jsx_member_expr(&mut self, node: JSXMemberExpr) -> JSXMemberExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_member_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_member_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_namespaced_name(
-        &mut self,
-        node: JSXNamespacedName,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXNamespacedName {
+    fn fold_jsx_namespaced_name(&mut self, node: JSXNamespacedName) -> JSXNamespacedName {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_namespaced_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_namespaced_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
+    fn fold_jsx_object(&mut self, node: JSXObject) -> JSXObject {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_object(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_object(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_element(
-        &mut self,
-        node: JSXOpeningElement,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningElement {
+    fn fold_jsx_opening_element(&mut self, node: JSXOpeningElement) -> JSXOpeningElement {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_opening_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_opening_element(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_opening_fragment(
-        &mut self,
-        node: JSXOpeningFragment,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXOpeningFragment {
+    fn fold_jsx_opening_fragment(&mut self, node: JSXOpeningFragment) -> JSXOpeningFragment {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_opening_fragment(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_opening_fragment(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_spread_child(
-        &mut self,
-        node: JSXSpreadChild,
-        __ast_path: &mut AstKindPath,
-    ) -> JSXSpreadChild {
+    fn fold_jsx_spread_child(&mut self, node: JSXSpreadChild) -> JSXSpreadChild {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_spread_child(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_spread_child(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
+    fn fold_jsx_text(&mut self, node: JSXText) -> JSXText {
         if self.enabled {
-            <V as FoldAstPath>::fold_jsx_text(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_jsx_text(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
+    fn fold_key(&mut self, node: Key) -> Key {
         if self.enabled {
-            <V as FoldAstPath>::fold_key(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_key(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_key_value_pat_prop(
-        &mut self,
-        node: KeyValuePatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValuePatProp {
+    fn fold_key_value_pat_prop(&mut self, node: KeyValuePatProp) -> KeyValuePatProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_key_value_pat_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_key_value_pat_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_key_value_prop(
-        &mut self,
-        node: KeyValueProp,
-        __ast_path: &mut AstKindPath,
-    ) -> KeyValueProp {
+    fn fold_key_value_prop(&mut self, node: KeyValueProp) -> KeyValueProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_key_value_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_key_value_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_labeled_stmt(
-        &mut self,
-        node: LabeledStmt,
-        __ast_path: &mut AstKindPath,
-    ) -> LabeledStmt {
+    fn fold_labeled_stmt(&mut self, node: LabeledStmt) -> LabeledStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_labeled_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_labeled_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
+    fn fold_lit(&mut self, node: Lit) -> Lit {
         if self.enabled {
-            <V as FoldAstPath>::fold_lit(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_lit(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
+    fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_member_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_member_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
+    fn fold_member_prop(&mut self, node: MemberProp) -> MemberProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_member_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_member_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_meta_prop_expr(
-        &mut self,
-        node: MetaPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropExpr {
+    fn fold_meta_prop_expr(&mut self, node: MetaPropExpr) -> MetaPropExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_meta_prop_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_meta_prop_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_meta_prop_kind(
-        &mut self,
-        node: MetaPropKind,
-        __ast_path: &mut AstKindPath,
-    ) -> MetaPropKind {
+    fn fold_meta_prop_kind(&mut self, node: MetaPropKind) -> MetaPropKind {
         if self.enabled {
-            <V as FoldAstPath>::fold_meta_prop_kind(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_meta_prop_kind(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
+    fn fold_method_kind(&mut self, node: MethodKind) -> MethodKind {
         if self.enabled {
-            <V as FoldAstPath>::fold_method_kind(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_method_kind(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
+    fn fold_method_prop(&mut self, node: MethodProp) -> MethodProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_method_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_method_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
+    fn fold_module(&mut self, node: Module) -> Module {
         if self.enabled {
-            <V as FoldAstPath>::fold_module(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_module(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
+    fn fold_module_decl(&mut self, node: ModuleDecl) -> ModuleDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_module_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_module_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_module_export_name(
-        &mut self,
-        node: ModuleExportName,
-        __ast_path: &mut AstKindPath,
-    ) -> ModuleExportName {
+    fn fold_module_export_name(&mut self, node: ModuleExportName) -> ModuleExportName {
         if self.enabled {
-            <V as FoldAstPath>::fold_module_export_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_module_export_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
+    fn fold_module_item(&mut self, node: ModuleItem) -> ModuleItem {
         if self.enabled {
-            <V as FoldAstPath>::fold_module_item(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_module_item(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_module_items(
-        &mut self,
-        node: Vec<ModuleItem>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ModuleItem> {
+    fn fold_module_items(&mut self, node: Vec<ModuleItem>) -> Vec<ModuleItem> {
         if self.enabled {
-            <V as FoldAstPath>::fold_module_items(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_module_items(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_named_export(
-        &mut self,
-        node: NamedExport,
-        __ast_path: &mut AstKindPath,
-    ) -> NamedExport {
+    fn fold_named_export(&mut self, node: NamedExport) -> NamedExport {
         if self.enabled {
-            <V as FoldAstPath>::fold_named_export(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_named_export(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
+    fn fold_new_expr(&mut self, node: NewExpr) -> NewExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_new_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_new_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
+    fn fold_null(&mut self, node: Null) -> Null {
         if self.enabled {
-            <V as FoldAstPath>::fold_null(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_null(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+    fn fold_number(&mut self, node: Number) -> Number {
         if self.enabled {
-            <V as FoldAstPath>::fold_number(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_number(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
+    fn fold_object_lit(&mut self, node: ObjectLit) -> ObjectLit {
         if self.enabled {
-            <V as FoldAstPath>::fold_object_lit(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_object_lit(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
+    fn fold_object_pat(&mut self, node: ObjectPat) -> ObjectPat {
         if self.enabled {
-            <V as FoldAstPath>::fold_object_pat(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_object_pat(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_object_pat_prop(
-        &mut self,
-        node: ObjectPatProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ObjectPatProp {
+    fn fold_object_pat_prop(&mut self, node: ObjectPatProp) -> ObjectPatProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_object_pat_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_object_pat_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_object_pat_props(
-        &mut self,
-        node: Vec<ObjectPatProp>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<ObjectPatProp> {
+    fn fold_object_pat_props(&mut self, node: Vec<ObjectPatProp>) -> Vec<ObjectPatProp> {
         if self.enabled {
-            <V as FoldAstPath>::fold_object_pat_props(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_object_pat_props(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_accessibility(
-        &mut self,
-        node: Option<Accessibility>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Accessibility> {
+    fn fold_opt_accessibility(&mut self, node: Option<Accessibility>) -> Option<Accessibility> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_accessibility(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_accessibility(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_atom(
-        &mut self,
-        node: Option<swc_atoms::Atom>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_atoms::Atom> {
+    fn fold_opt_atom(&mut self, node: Option<swc_atoms::Atom>) -> Option<swc_atoms::Atom> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_atom(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_atom(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_block_stmt(
-        &mut self,
-        node: Option<BlockStmt>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<BlockStmt> {
+    fn fold_opt_block_stmt(&mut self, node: Option<BlockStmt>) -> Option<BlockStmt> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_block_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_block_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
+    fn fold_opt_call(&mut self, node: OptCall) -> OptCall {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_call(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_call(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_catch_clause(
-        &mut self,
-        node: Option<CatchClause>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<CatchClause> {
+    fn fold_opt_catch_clause(&mut self, node: Option<CatchClause>) -> Option<CatchClause> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_catch_clause(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_catch_clause(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_chain_base(
-        &mut self,
-        node: OptChainBase,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainBase {
+    fn fold_opt_chain_base(&mut self, node: OptChainBase) -> OptChainBase {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_chain_base(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_chain_base(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_chain_expr(
-        &mut self,
-        node: OptChainExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> OptChainExpr {
+    fn fold_opt_chain_expr(&mut self, node: OptChainExpr) -> OptChainExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_chain_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_chain_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_expr(
-        &mut self,
-        node: Option<Box<Expr>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Expr>> {
+    fn fold_opt_expr(&mut self, node: Option<Box<Expr>>) -> Option<Box<Expr>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_expr_or_spread(
-        &mut self,
-        node: Option<ExprOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<ExprOrSpread> {
+    fn fold_opt_expr_or_spread(&mut self, node: Option<ExprOrSpread>) -> Option<ExprOrSpread> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_expr_or_spread(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_expr_or_spread(&mut self.visitor, node)
         } else {
             node
         }
@@ -122810,36 +100109,27 @@ where
     fn fold_opt_expr_or_spreads(
         &mut self,
         node: Option<Vec<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Vec<ExprOrSpread>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_expr_or_spreads(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_expr_or_spreads(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_ident(
-        &mut self,
-        node: Option<Ident>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Ident> {
+    fn fold_opt_ident(&mut self, node: Option<Ident>) -> Option<Ident> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_ident(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_jsx_attr_value(
-        &mut self,
-        node: Option<JSXAttrValue>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<JSXAttrValue> {
+    fn fold_opt_jsx_attr_value(&mut self, node: Option<JSXAttrValue>) -> Option<JSXAttrValue> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_jsx_attr_value(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_jsx_attr_value(&mut self.visitor, node)
         } else {
             node
         }
@@ -122849,10 +100139,9 @@ where
     fn fold_opt_jsx_closing_element(
         &mut self,
         node: Option<JSXClosingElement>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<JSXClosingElement> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_jsx_closing_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_jsx_closing_element(&mut self.visitor, node)
         } else {
             node
         }
@@ -122862,97 +100151,72 @@ where
     fn fold_opt_module_export_name(
         &mut self,
         node: Option<ModuleExportName>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<ModuleExportName> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_module_export_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_module_export_name(&mut self.visitor, node)
         } else {
             node
         }
-    }
-
-    #[inline]
-    fn fold_opt_object_lit(
-        &mut self,
-        node: Option<Box<ObjectLit>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<ObjectLit>> {
+    }
+
+    #[inline]
+    fn fold_opt_object_lit(&mut self, node: Option<Box<ObjectLit>>) -> Option<Box<ObjectLit>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_object_lit(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_object_lit(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
+    fn fold_opt_pat(&mut self, node: Option<Pat>) -> Option<Pat> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_pat(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_pat(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_span(
-        &mut self,
-        node: Option<swc_common::Span>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<swc_common::Span> {
+    fn fold_opt_span(&mut self, node: Option<swc_common::Span>) -> Option<swc_common::Span> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_span(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_span(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_stmt(
-        &mut self,
-        node: Option<Box<Stmt>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Stmt>> {
+    fn fold_opt_stmt(&mut self, node: Option<Box<Stmt>>) -> Option<Box<Stmt>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_str(
-        &mut self,
-        node: Option<Box<Str>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<Str>> {
+    fn fold_opt_str(&mut self, node: Option<Box<Str>>) -> Option<Box<Str>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_str(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_str(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_true_plus_minus(
-        &mut self,
-        node: Option<TruePlusMinus>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TruePlusMinus> {
+    fn fold_opt_true_plus_minus(&mut self, node: Option<TruePlusMinus>) -> Option<TruePlusMinus> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_true_plus_minus(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_true_plus_minus(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_entity_name(
-        &mut self,
-        node: Option<TsEntityName>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<TsEntityName> {
+    fn fold_opt_ts_entity_name(&mut self, node: Option<TsEntityName>) -> Option<TsEntityName> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ts_entity_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_ts_entity_name(&mut self.visitor, node)
         } else {
             node
         }
@@ -122962,36 +100226,27 @@ where
     fn fold_opt_ts_namespace_body(
         &mut self,
         node: Option<TsNamespaceBody>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<TsNamespaceBody> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ts_namespace_body(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_ts_namespace_body(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type(
-        &mut self,
-        node: Option<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsType>> {
+    fn fold_opt_ts_type(&mut self, node: Option<Box<TsType>>) -> Option<Box<TsType>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ts_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_ts_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_ts_type_ann(
-        &mut self,
-        node: Option<Box<TsTypeAnn>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<Box<TsTypeAnn>> {
+    fn fold_opt_ts_type_ann(&mut self, node: Option<Box<TsTypeAnn>>) -> Option<Box<TsTypeAnn>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ts_type_ann(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_ts_type_ann(&mut self.visitor, node)
         } else {
             node
         }
@@ -123001,10 +100256,9 @@ where
     fn fold_opt_ts_type_param_decl(
         &mut self,
         node: Option<Box<TsTypeParamDecl>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamDecl>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ts_type_param_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_ts_type_param_decl(&mut self.visitor, node)
         } else {
             node
         }
@@ -123014,27 +100268,18 @@ where
     fn fold_opt_ts_type_param_instantiation(
         &mut self,
         node: Option<Box<TsTypeParamInstantiation>>,
-        __ast_path: &mut AstKindPath,
     ) -> Option<Box<TsTypeParamInstantiation>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_opt_ts_type_param_instantiation(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_var_decl_or_expr(
-        &mut self,
-        node: Option<VarDeclOrExpr>,
-        __ast_path: &mut AstKindPath,
-    ) -> Option<VarDeclOrExpr> {
+    fn fold_opt_var_decl_or_expr(&mut self, node: Option<VarDeclOrExpr>) -> Option<VarDeclOrExpr> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_var_decl_or_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_var_decl_or_expr(&mut self.visitor, node)
         } else {
             node
         }
@@ -123044,45 +100289,36 @@ where
     fn fold_opt_vec_expr_or_spreads(
         &mut self,
         node: Vec<Option<ExprOrSpread>>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<Option<ExprOrSpread>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_vec_expr_or_spreads(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_opt_vec_pats(
-        &mut self,
-        node: Vec<Option<Pat>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Option<Pat>> {
+    fn fold_opt_vec_pats(&mut self, node: Vec<Option<Pat>>) -> Vec<Option<Pat>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_opt_vec_pats(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_opt_vec_pats(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
+    fn fold_param(&mut self, node: Param) -> Param {
         if self.enabled {
-            <V as FoldAstPath>::fold_param(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_param(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_param_or_ts_param_prop(
-        &mut self,
-        node: ParamOrTsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> ParamOrTsParamProp {
+    fn fold_param_or_ts_param_prop(&mut self, node: ParamOrTsParamProp) -> ParamOrTsParamProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_param_or_ts_param_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_param_or_ts_param_prop(&mut self.visitor, node)
         } else {
             node
         }
@@ -123092,333 +100328,288 @@ where
     fn fold_param_or_ts_param_props(
         &mut self,
         node: Vec<ParamOrTsParamProp>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<ParamOrTsParamProp> {
         if self.enabled {
-            <V as FoldAstPath>::fold_param_or_ts_param_props(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_param_or_ts_param_props(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
+    fn fold_params(&mut self, node: Vec<Param>) -> Vec<Param> {
         if self.enabled {
-            <V as FoldAstPath>::fold_params(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_params(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
+    fn fold_paren_expr(&mut self, node: ParenExpr) -> ParenExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_paren_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_paren_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
+    fn fold_pat(&mut self, node: Pat) -> Pat {
         if self.enabled {
-            <V as FoldAstPath>::fold_pat(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_pat(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
+    fn fold_pats(&mut self, node: Vec<Pat>) -> Vec<Pat> {
         if self.enabled {
-            <V as FoldAstPath>::fold_pats(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_pats(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_private_method(
-        &mut self,
-        node: PrivateMethod,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateMethod {
+    fn fold_private_method(&mut self, node: PrivateMethod) -> PrivateMethod {
         if self.enabled {
-            <V as FoldAstPath>::fold_private_method(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_private_method(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_private_name(
-        &mut self,
-        node: PrivateName,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateName {
+    fn fold_private_name(&mut self, node: PrivateName) -> PrivateName {
         if self.enabled {
-            <V as FoldAstPath>::fold_private_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_private_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_private_prop(
-        &mut self,
-        node: PrivateProp,
-        __ast_path: &mut AstKindPath,
-    ) -> PrivateProp {
+    fn fold_private_prop(&mut self, node: PrivateProp) -> PrivateProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_private_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_private_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
+    fn fold_program(&mut self, node: Program) -> Program {
         if self.enabled {
-            <V as FoldAstPath>::fold_program(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_program(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
+    fn fold_prop(&mut self, node: Prop) -> Prop {
         if self.enabled {
-            <V as FoldAstPath>::fold_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
+    fn fold_prop_name(&mut self, node: PropName) -> PropName {
         if self.enabled {
-            <V as FoldAstPath>::fold_prop_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_prop_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_prop_or_spread(
-        &mut self,
-        node: PropOrSpread,
-        __ast_path: &mut AstKindPath,
-    ) -> PropOrSpread {
+    fn fold_prop_or_spread(&mut self, node: PropOrSpread) -> PropOrSpread {
         if self.enabled {
-            <V as FoldAstPath>::fold_prop_or_spread(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_prop_or_spread(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_prop_or_spreads(
-        &mut self,
-        node: Vec<PropOrSpread>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<PropOrSpread> {
+    fn fold_prop_or_spreads(&mut self, node: Vec<PropOrSpread>) -> Vec<PropOrSpread> {
         if self.enabled {
-            <V as FoldAstPath>::fold_prop_or_spreads(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_prop_or_spreads(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
+    fn fold_regex(&mut self, node: Regex) -> Regex {
         if self.enabled {
-            <V as FoldAstPath>::fold_regex(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_regex(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
+    fn fold_rest_pat(&mut self, node: RestPat) -> RestPat {
         if self.enabled {
-            <V as FoldAstPath>::fold_rest_pat(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_rest_pat(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
+    fn fold_return_stmt(&mut self, node: ReturnStmt) -> ReturnStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_return_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_return_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
+    fn fold_script(&mut self, node: Script) -> Script {
         if self.enabled {
-            <V as FoldAstPath>::fold_script(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_script(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
+    fn fold_seq_expr(&mut self, node: SeqExpr) -> SeqExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_seq_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_seq_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
+    fn fold_setter_prop(&mut self, node: SetterProp) -> SetterProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_setter_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_setter_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_simple_assign_target(
-        &mut self,
-        node: SimpleAssignTarget,
-        __ast_path: &mut AstKindPath,
-    ) -> SimpleAssignTarget {
+    fn fold_simple_assign_target(&mut self, node: SimpleAssignTarget) -> SimpleAssignTarget {
         if self.enabled {
-            <V as FoldAstPath>::fold_simple_assign_target(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_simple_assign_target(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_span(
-        &mut self,
-        node: swc_common::Span,
-        __ast_path: &mut AstKindPath,
-    ) -> swc_common::Span {
+    fn fold_span(&mut self, node: swc_common::Span) -> swc_common::Span {
         if self.enabled {
-            <V as FoldAstPath>::fold_span(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_span(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_spread_element(
-        &mut self,
-        node: SpreadElement,
-        __ast_path: &mut AstKindPath,
-    ) -> SpreadElement {
+    fn fold_spread_element(&mut self, node: SpreadElement) -> SpreadElement {
         if self.enabled {
-            <V as FoldAstPath>::fold_spread_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_spread_element(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_static_block(
-        &mut self,
-        node: StaticBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> StaticBlock {
+    fn fold_static_block(&mut self, node: StaticBlock) -> StaticBlock {
         if self.enabled {
-            <V as FoldAstPath>::fold_static_block(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_static_block(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
+    fn fold_stmt(&mut self, node: Stmt) -> Stmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
+    fn fold_stmts(&mut self, node: Vec<Stmt>) -> Vec<Stmt> {
         if self.enabled {
-            <V as FoldAstPath>::fold_stmts(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_stmts(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+    fn fold_str(&mut self, node: Str) -> Str {
         if self.enabled {
-            <V as FoldAstPath>::fold_str(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_str(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
+    fn fold_super(&mut self, node: Super) -> Super {
         if self.enabled {
-            <V as FoldAstPath>::fold_super(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_super(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
+    fn fold_super_prop(&mut self, node: SuperProp) -> SuperProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_super_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_super_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_super_prop_expr(
-        &mut self,
-        node: SuperPropExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> SuperPropExpr {
+    fn fold_super_prop_expr(&mut self, node: SuperPropExpr) -> SuperPropExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_super_prop_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_super_prop_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
+    fn fold_switch_case(&mut self, node: SwitchCase) -> SwitchCase {
         if self.enabled {
-            <V as FoldAstPath>::fold_switch_case(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_switch_case(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_switch_cases(
-        &mut self,
-        node: Vec<SwitchCase>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<SwitchCase> {
+    fn fold_switch_cases(&mut self, node: Vec<SwitchCase>) -> Vec<SwitchCase> {
         if self.enabled {
-            <V as FoldAstPath>::fold_switch_cases(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_switch_cases(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
+    fn fold_switch_stmt(&mut self, node: SwitchStmt) -> SwitchStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_switch_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_switch_stmt(&mut self.visitor, node)
         } else {
             node
         }
@@ -123428,151 +100619,126 @@ where
     fn fold_syntax_context(
         &mut self,
         node: swc_common::SyntaxContext,
-        __ast_path: &mut AstKindPath,
     ) -> swc_common::SyntaxContext {
         if self.enabled {
-            <V as FoldAstPath>::fold_syntax_context(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_syntax_context(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl) -> TaggedTpl {
         if self.enabled {
-            <V as FoldAstPath>::fold_tagged_tpl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_tagged_tpl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
+    fn fold_this_expr(&mut self, node: ThisExpr) -> ThisExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_this_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_this_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
+    fn fold_throw_stmt(&mut self, node: ThrowStmt) -> ThrowStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_throw_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_throw_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
+    fn fold_tpl(&mut self, node: Tpl) -> Tpl {
         if self.enabled {
-            <V as FoldAstPath>::fold_tpl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_tpl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
+    fn fold_tpl_element(&mut self, node: TplElement) -> TplElement {
         if self.enabled {
-            <V as FoldAstPath>::fold_tpl_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_tpl_element(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_tpl_elements(
-        &mut self,
-        node: Vec<TplElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TplElement> {
+    fn fold_tpl_elements(&mut self, node: Vec<TplElement>) -> Vec<TplElement> {
         if self.enabled {
-            <V as FoldAstPath>::fold_tpl_elements(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_tpl_elements(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_true_plus_minus(
-        &mut self,
-        node: TruePlusMinus,
-        __ast_path: &mut AstKindPath,
-    ) -> TruePlusMinus {
+    fn fold_true_plus_minus(&mut self, node: TruePlusMinus) -> TruePlusMinus {
         if self.enabled {
-            <V as FoldAstPath>::fold_true_plus_minus(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_true_plus_minus(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
+    fn fold_try_stmt(&mut self, node: TryStmt) -> TryStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_try_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_try_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_array_type(
-        &mut self,
-        node: TsArrayType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsArrayType {
+    fn fold_ts_array_type(&mut self, node: TsArrayType) -> TsArrayType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_array_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_array_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr) -> TsAsExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_as_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_as_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_call_signature_decl(
-        &mut self,
-        node: TsCallSignatureDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsCallSignatureDecl {
+    fn fold_ts_call_signature_decl(&mut self, node: TsCallSignatureDecl) -> TsCallSignatureDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_call_signature_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_call_signature_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_conditional_type(
-        &mut self,
-        node: TsConditionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConditionalType {
+    fn fold_ts_conditional_type(&mut self, node: TsConditionalType) -> TsConditionalType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_conditional_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_conditional_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_const_assertion(
-        &mut self,
-        node: TsConstAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstAssertion {
+    fn fold_ts_const_assertion(&mut self, node: TsConstAssertion) -> TsConstAssertion {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_const_assertion(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_const_assertion(&mut self.visitor, node)
         } else {
             node
         }
@@ -123582,114 +100748,81 @@ where
     fn fold_ts_construct_signature_decl(
         &mut self,
         node: TsConstructSignatureDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsConstructSignatureDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_construct_signature_decl(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_ts_construct_signature_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_constructor_type(
-        &mut self,
-        node: TsConstructorType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsConstructorType {
+    fn fold_ts_constructor_type(&mut self, node: TsConstructorType) -> TsConstructorType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_constructor_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_constructor_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_entity_name(
-        &mut self,
-        node: TsEntityName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEntityName {
+    fn fold_ts_entity_name(&mut self, node: TsEntityName) -> TsEntityName {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_entity_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_entity_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl) -> TsEnumDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_enum_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_enum_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member(
-        &mut self,
-        node: TsEnumMember,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMember {
+    fn fold_ts_enum_member(&mut self, node: TsEnumMember) -> TsEnumMember {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_enum_member(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_enum_member(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_member_id(
-        &mut self,
-        node: TsEnumMemberId,
-        __ast_path: &mut AstKindPath,
-    ) -> TsEnumMemberId {
+    fn fold_ts_enum_member_id(&mut self, node: TsEnumMemberId) -> TsEnumMemberId {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_enum_member_id(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_enum_member_id(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_enum_members(
-        &mut self,
-        node: Vec<TsEnumMember>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsEnumMember> {
+    fn fold_ts_enum_members(&mut self, node: Vec<TsEnumMember>) -> Vec<TsEnumMember> {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_enum_members(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_enum_members(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_export_assignment(
-        &mut self,
-        node: TsExportAssignment,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExportAssignment {
+    fn fold_ts_export_assignment(&mut self, node: TsExportAssignment) -> TsExportAssignment {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_export_assignment(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_export_assignment(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_expr_with_type_args(
-        &mut self,
-        node: TsExprWithTypeArgs,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExprWithTypeArgs {
+    fn fold_ts_expr_with_type_args(&mut self, node: TsExprWithTypeArgs) -> TsExprWithTypeArgs {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_expr_with_type_args(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_expr_with_type_args(&mut self.visitor, node)
         } else {
             node
         }
@@ -123699,23 +100832,18 @@ where
     fn fold_ts_expr_with_type_argss(
         &mut self,
         node: Vec<TsExprWithTypeArgs>,
-        __ast_path: &mut AstKindPath,
     ) -> Vec<TsExprWithTypeArgs> {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_expr_with_type_argss(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_expr_with_type_argss(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_external_module_ref(
-        &mut self,
-        node: TsExternalModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsExternalModuleRef {
+    fn fold_ts_external_module_ref(&mut self, node: TsExternalModuleRef) -> TsExternalModuleRef {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_external_module_ref(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_external_module_ref(&mut self.visitor, node)
         } else {
             node
         }
@@ -123725,319 +100853,234 @@ where
     fn fold_ts_fn_or_constructor_type(
         &mut self,
         node: TsFnOrConstructorType,
-        __ast_path: &mut AstKindPath,
     ) -> TsFnOrConstructorType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_fn_or_constructor_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_fn_or_constructor_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
+    fn fold_ts_fn_param(&mut self, node: TsFnParam) -> TsFnParam {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_fn_param(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_fn_param(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_fn_params(
-        &mut self,
-        node: Vec<TsFnParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsFnParam> {
+    fn fold_ts_fn_params(&mut self, node: Vec<TsFnParam>) -> Vec<TsFnParam> {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_fn_params(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_fn_params(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
+    fn fold_ts_fn_type(&mut self, node: TsFnType) -> TsFnType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_fn_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_fn_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_getter_signature(
-        &mut self,
-        node: TsGetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsGetterSignature {
+    fn fold_ts_getter_signature(&mut self, node: TsGetterSignature) -> TsGetterSignature {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_getter_signature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_getter_signature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_import_equals_decl(
-        &mut self,
-        node: TsImportEqualsDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportEqualsDecl {
+    fn fold_ts_import_equals_decl(&mut self, node: TsImportEqualsDecl) -> TsImportEqualsDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_import_equals_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_import_equals_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_import_type(
-        &mut self,
-        node: TsImportType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsImportType {
+    fn fold_ts_import_type(&mut self, node: TsImportType) -> TsImportType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_import_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_import_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_index_signature(
-        &mut self,
-        node: TsIndexSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexSignature {
+    fn fold_ts_index_signature(&mut self, node: TsIndexSignature) -> TsIndexSignature {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_index_signature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_index_signature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_indexed_access_type(
-        &mut self,
-        node: TsIndexedAccessType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIndexedAccessType {
+    fn fold_ts_indexed_access_type(&mut self, node: TsIndexedAccessType) -> TsIndexedAccessType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_indexed_access_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_indexed_access_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_infer_type(
-        &mut self,
-        node: TsInferType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInferType {
+    fn fold_ts_infer_type(&mut self, node: TsInferType) -> TsInferType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_infer_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_infer_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_instantiation(
-        &mut self,
-        node: TsInstantiation,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInstantiation {
+    fn fold_ts_instantiation(&mut self, node: TsInstantiation) -> TsInstantiation {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_instantiation(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_instantiation(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_interface_body(
-        &mut self,
-        node: TsInterfaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceBody {
+    fn fold_ts_interface_body(&mut self, node: TsInterfaceBody) -> TsInterfaceBody {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_interface_body(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_interface_body(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_interface_decl(
-        &mut self,
-        node: TsInterfaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsInterfaceDecl {
+    fn fold_ts_interface_decl(&mut self, node: TsInterfaceDecl) -> TsInterfaceDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_interface_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_interface_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_intersection_type(
-        &mut self,
-        node: TsIntersectionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsIntersectionType {
+    fn fold_ts_intersection_type(&mut self, node: TsIntersectionType) -> TsIntersectionType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_intersection_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_intersection_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type(
-        &mut self,
-        node: TsKeywordType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordType {
+    fn fold_ts_keyword_type(&mut self, node: TsKeywordType) -> TsKeywordType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_keyword_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_keyword_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_keyword_type_kind(
-        &mut self,
-        node: TsKeywordTypeKind,
-        __ast_path: &mut AstKindPath,
-    ) -> TsKeywordTypeKind {
+    fn fold_ts_keyword_type_kind(&mut self, node: TsKeywordTypeKind) -> TsKeywordTypeKind {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_keyword_type_kind(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_keyword_type_kind(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
+    fn fold_ts_lit(&mut self, node: TsLit) -> TsLit {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_lit(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_lit(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
+    fn fold_ts_lit_type(&mut self, node: TsLitType) -> TsLitType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_lit_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_lit_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_mapped_type(
-        &mut self,
-        node: TsMappedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMappedType {
+    fn fold_ts_mapped_type(&mut self, node: TsMappedType) -> TsMappedType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_mapped_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_mapped_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_method_signature(
-        &mut self,
-        node: TsMethodSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsMethodSignature {
+    fn fold_ts_method_signature(&mut self, node: TsMethodSignature) -> TsMethodSignature {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_method_signature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_method_signature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_module_block(
-        &mut self,
-        node: TsModuleBlock,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleBlock {
+    fn fold_ts_module_block(&mut self, node: TsModuleBlock) -> TsModuleBlock {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_module_block(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_module_block(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_module_decl(
-        &mut self,
-        node: TsModuleDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleDecl {
+    fn fold_ts_module_decl(&mut self, node: TsModuleDecl) -> TsModuleDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_module_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_module_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_module_name(
-        &mut self,
-        node: TsModuleName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleName {
+    fn fold_ts_module_name(&mut self, node: TsModuleName) -> TsModuleName {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_module_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_module_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_module_ref(
-        &mut self,
-        node: TsModuleRef,
-        __ast_path: &mut AstKindPath,
-    ) -> TsModuleRef {
+    fn fold_ts_module_ref(&mut self, node: TsModuleRef) -> TsModuleRef {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_module_ref(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_module_ref(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_body(
-        &mut self,
-        node: TsNamespaceBody,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceBody {
+    fn fold_ts_namespace_body(&mut self, node: TsNamespaceBody) -> TsNamespaceBody {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_namespace_body(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_namespace_body(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_namespace_decl(
-        &mut self,
-        node: TsNamespaceDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNamespaceDecl {
+    fn fold_ts_namespace_decl(&mut self, node: TsNamespaceDecl) -> TsNamespaceDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_namespace_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_namespace_decl(&mut self.visitor, node)
         } else {
             node
         }
@@ -124047,341 +101090,252 @@ where
     fn fold_ts_namespace_export_decl(
         &mut self,
         node: TsNamespaceExportDecl,
-        __ast_path: &mut AstKindPath,
     ) -> TsNamespaceExportDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_namespace_export_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_namespace_export_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_non_null_expr(
-        &mut self,
-        node: TsNonNullExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsNonNullExpr {
+    fn fold_ts_non_null_expr(&mut self, node: TsNonNullExpr) -> TsNonNullExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_non_null_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_non_null_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_optional_type(
-        &mut self,
-        node: TsOptionalType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsOptionalType {
+    fn fold_ts_optional_type(&mut self, node: TsOptionalType) -> TsOptionalType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_optional_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_optional_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop(
-        &mut self,
-        node: TsParamProp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamProp {
+    fn fold_ts_param_prop(&mut self, node: TsParamProp) -> TsParamProp {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_param_prop(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_param_prop(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_param_prop_param(
-        &mut self,
-        node: TsParamPropParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParamPropParam {
+    fn fold_ts_param_prop_param(&mut self, node: TsParamPropParam) -> TsParamPropParam {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_param_prop_param(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_param_prop_param(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_parenthesized_type(
-        &mut self,
-        node: TsParenthesizedType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsParenthesizedType {
+    fn fold_ts_parenthesized_type(&mut self, node: TsParenthesizedType) -> TsParenthesizedType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_parenthesized_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_parenthesized_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_property_signature(
-        &mut self,
-        node: TsPropertySignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsPropertySignature {
+    fn fold_ts_property_signature(&mut self, node: TsPropertySignature) -> TsPropertySignature {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_property_signature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_property_signature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_qualified_name(
-        &mut self,
-        node: TsQualifiedName,
-        __ast_path: &mut AstKindPath,
-    ) -> TsQualifiedName {
+    fn fold_ts_qualified_name(&mut self, node: TsQualifiedName) -> TsQualifiedName {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_qualified_name(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_qualified_name(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
+    fn fold_ts_rest_type(&mut self, node: TsRestType) -> TsRestType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_rest_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_rest_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_satisfies_expr(
-        &mut self,
-        node: TsSatisfiesExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSatisfiesExpr {
+    fn fold_ts_satisfies_expr(&mut self, node: TsSatisfiesExpr) -> TsSatisfiesExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_satisfies_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_satisfies_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_setter_signature(
-        &mut self,
-        node: TsSetterSignature,
-        __ast_path: &mut AstKindPath,
-    ) -> TsSetterSignature {
+    fn fold_ts_setter_signature(&mut self, node: TsSetterSignature) -> TsSetterSignature {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_setter_signature(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_setter_signature(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
+    fn fold_ts_this_type(&mut self, node: TsThisType) -> TsThisType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_this_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_this_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_this_type_or_ident(
-        &mut self,
-        node: TsThisTypeOrIdent,
-        __ast_path: &mut AstKindPath,
-    ) -> TsThisTypeOrIdent {
+    fn fold_ts_this_type_or_ident(&mut self, node: TsThisTypeOrIdent) -> TsThisTypeOrIdent {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_this_type_or_ident(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_this_type_or_ident(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_tpl_lit_type(
-        &mut self,
-        node: TsTplLitType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTplLitType {
+    fn fold_ts_tpl_lit_type(&mut self, node: TsTplLitType) -> TsTplLitType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_tpl_lit_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_tpl_lit_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_element(
-        &mut self,
-        node: TsTupleElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleElement {
+    fn fold_ts_tuple_element(&mut self, node: TsTupleElement) -> TsTupleElement {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_tuple_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_tuple_element(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_elements(
-        &mut self,
-        node: Vec<TsTupleElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTupleElement> {
+    fn fold_ts_tuple_elements(&mut self, node: Vec<TsTupleElement>) -> Vec<TsTupleElement> {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_tuple_elements(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_tuple_elements(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_tuple_type(
-        &mut self,
-        node: TsTupleType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTupleType {
+    fn fold_ts_tuple_type(&mut self, node: TsTupleType) -> TsTupleType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_tuple_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_tuple_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
+    fn fold_ts_type(&mut self, node: TsType) -> TsType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_alias_decl(
-        &mut self,
-        node: TsTypeAliasDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAliasDecl {
+    fn fold_ts_type_alias_decl(&mut self, node: TsTypeAliasDecl) -> TsTypeAliasDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_alias_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_alias_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn) -> TsTypeAnn {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_ann(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_ann(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_assertion(
-        &mut self,
-        node: TsTypeAssertion,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeAssertion {
+    fn fold_ts_type_assertion(&mut self, node: TsTypeAssertion) -> TsTypeAssertion {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_assertion(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_assertion(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_element(
-        &mut self,
-        node: TsTypeElement,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeElement {
+    fn fold_ts_type_element(&mut self, node: TsTypeElement) -> TsTypeElement {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_element(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_element(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_elements(
-        &mut self,
-        node: Vec<TsTypeElement>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeElement> {
+    fn fold_ts_type_elements(&mut self, node: Vec<TsTypeElement>) -> Vec<TsTypeElement> {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_elements(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_elements(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit) -> TsTypeLit {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_lit(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_lit(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator(
-        &mut self,
-        node: TsTypeOperator,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperator {
+    fn fold_ts_type_operator(&mut self, node: TsTypeOperator) -> TsTypeOperator {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_operator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_operator(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_operator_op(
-        &mut self,
-        node: TsTypeOperatorOp,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeOperatorOp {
+    fn fold_ts_type_operator_op(&mut self, node: TsTypeOperatorOp) -> TsTypeOperatorOp {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_operator_op(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_operator_op(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_param(
-        &mut self,
-        node: TsTypeParam,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParam {
+    fn fold_ts_type_param(&mut self, node: TsTypeParam) -> TsTypeParam {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_param(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_param(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_param_decl(
-        &mut self,
-        node: TsTypeParamDecl,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeParamDecl {
+    fn fold_ts_type_param_decl(&mut self, node: TsTypeParamDecl) -> TsTypeParamDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_param_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_param_decl(&mut self.visitor, node)
         } else {
             node
         }
@@ -124391,88 +101345,63 @@ where
     fn fold_ts_type_param_instantiation(
         &mut self,
         node: TsTypeParamInstantiation,
-        __ast_path: &mut AstKindPath,
     ) -> TsTypeParamInstantiation {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_param_instantiation(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_ts_type_param_instantiation(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_params(
-        &mut self,
-        node: Vec<TsTypeParam>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<TsTypeParam> {
+    fn fold_ts_type_params(&mut self, node: Vec<TsTypeParam>) -> Vec<TsTypeParam> {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_params(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_params(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_predicate(
-        &mut self,
-        node: TsTypePredicate,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypePredicate {
+    fn fold_ts_type_predicate(&mut self, node: TsTypePredicate) -> TsTypePredicate {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_predicate(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_predicate(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_query(
-        &mut self,
-        node: TsTypeQuery,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQuery {
+    fn fold_ts_type_query(&mut self, node: TsTypeQuery) -> TsTypeQuery {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_query(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_query(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_query_expr(
-        &mut self,
-        node: TsTypeQueryExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> TsTypeQueryExpr {
+    fn fold_ts_type_query_expr(&mut self, node: TsTypeQueryExpr) -> TsTypeQueryExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_query_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_query_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef) -> TsTypeRef {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_type_ref(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_type_ref(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_types(
-        &mut self,
-        node: Vec<Box<TsType>>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<Box<TsType>> {
+    fn fold_ts_types(&mut self, node: Vec<Box<TsType>>) -> Vec<Box<TsType>> {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_types(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_types(&mut self.visitor, node)
         } else {
             node
         }
@@ -124482,183 +101411,154 @@ where
     fn fold_ts_union_or_intersection_type(
         &mut self,
         node: TsUnionOrIntersectionType,
-        __ast_path: &mut AstKindPath,
     ) -> TsUnionOrIntersectionType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_union_or_intersection_type(
-                &mut self.visitor,
-                node,
-                __ast_path,
-            )
+            <V as Fold>::fold_ts_union_or_intersection_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_ts_union_type(
-        &mut self,
-        node: TsUnionType,
-        __ast_path: &mut AstKindPath,
-    ) -> TsUnionType {
+    fn fold_ts_union_type(&mut self, node: TsUnionType) -> TsUnionType {
         if self.enabled {
-            <V as FoldAstPath>::fold_ts_union_type(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_ts_union_type(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
+    fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_unary_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_unary_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
+    fn fold_unary_op(&mut self, node: UnaryOp) -> UnaryOp {
         if self.enabled {
-            <V as FoldAstPath>::fold_unary_op(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_unary_op(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
+    fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_update_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_update_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
+    fn fold_update_op(&mut self, node: UpdateOp) -> UpdateOp {
         if self.enabled {
-            <V as FoldAstPath>::fold_update_op(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_update_op(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
+    fn fold_using_decl(&mut self, node: UsingDecl) -> UsingDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_using_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_using_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
+    fn fold_var_decl(&mut self, node: VarDecl) -> VarDecl {
         if self.enabled {
-            <V as FoldAstPath>::fold_var_decl(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_var_decl(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_var_decl_kind(
-        &mut self,
-        node: VarDeclKind,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclKind {
+    fn fold_var_decl_kind(&mut self, node: VarDeclKind) -> VarDeclKind {
         if self.enabled {
-            <V as FoldAstPath>::fold_var_decl_kind(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_var_decl_kind(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_var_decl_or_expr(
-        &mut self,
-        node: VarDeclOrExpr,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclOrExpr {
+    fn fold_var_decl_or_expr(&mut self, node: VarDeclOrExpr) -> VarDeclOrExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_var_decl_or_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_var_decl_or_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_var_declarator(
-        &mut self,
-        node: VarDeclarator,
-        __ast_path: &mut AstKindPath,
-    ) -> VarDeclarator {
+    fn fold_var_declarator(&mut self, node: VarDeclarator) -> VarDeclarator {
         if self.enabled {
-            <V as FoldAstPath>::fold_var_declarator(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_var_declarator(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_var_declarators(
-        &mut self,
-        node: Vec<VarDeclarator>,
-        __ast_path: &mut AstKindPath,
-    ) -> Vec<VarDeclarator> {
+    fn fold_var_declarators(&mut self, node: Vec<VarDeclarator>) -> Vec<VarDeclarator> {
         if self.enabled {
-            <V as FoldAstPath>::fold_var_declarators(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_var_declarators(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
+    fn fold_while_stmt(&mut self, node: WhileStmt) -> WhileStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_while_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_while_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
+    fn fold_with_stmt(&mut self, node: WithStmt) -> WithStmt {
         if self.enabled {
-            <V as FoldAstPath>::fold_with_stmt(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_with_stmt(&mut self.visitor, node)
         } else {
             node
         }
     }
 
     #[inline]
-    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
+    fn fold_yield_expr(&mut self, node: YieldExpr) -> YieldExpr {
         if self.enabled {
-            <V as FoldAstPath>::fold_yield_expr(&mut self.visitor, node, __ast_path)
+            <V as Fold>::fold_yield_expr(&mut self.visitor, node)
         } else {
             node
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-pub trait FoldWithAstPath<V: ?Sized + FoldAstPath> {
+pub trait FoldWith<V: ?Sized + Fold> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
+    fn fold_with(self, visitor: &mut V) -> Self;
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
+    fn fold_children_with(self, visitor: &mut V) -> Self;
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Accessibility {
-    #[doc = "Calls [FoldAstPath`::fold_accessibility`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_accessibility(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Accessibility {
+    #[doc = "Calls [Fold`::fold_accessibility`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_accessibility(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Accessibility::Public => Accessibility::Public,
             Accessibility::Protected => Accessibility::Protected,
@@ -124666,50 +101566,30 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Accessibility {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrayLit {
-    #[doc = "Calls [FoldAstPath`::fold_array_lit`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_array_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ArrayLit {
+    #[doc = "Calls [Fold`::fold_array_lit`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_array_lit(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ArrayLit { span, elems } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrayLit(self::fields::ArrayLitField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let elems = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayLit(
-                        self::fields::ArrayLitField::Elems(usize::MAX),
-                    ));
-                    <Vec<Option<ExprOrSpread>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        elems,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let elems =
+                    { <Vec<Option<ExprOrSpread>> as FoldWith<V>>::fold_with(elems, visitor) };
                 ArrayLit { span, elems }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrayPat {
-    #[doc = "Calls [FoldAstPath`::fold_array_pat`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_array_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ArrayPat {
+    #[doc = "Calls [Fold`::fold_array_pat`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_array_pat(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ArrayPat {
                 span,
@@ -124717,35 +101597,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrayPat {
                 optional,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrayPat(self::fields::ArrayPatField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let elems = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
-                        self::fields::ArrayPatField::Elems(usize::MAX),
-                    ));
-                    <Vec<Option<Pat>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        elems,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
-                        self::fields::ArrayPatField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let elems = { <Vec<Option<Pat>> as FoldWith<V>>::fold_with(elems, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 ArrayPat {
                     span,
                     elems,
@@ -124756,15 +101611,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrayPat {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrowExpr {
-    #[doc = "Calls [FoldAstPath`::fold_arrow_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_arrow_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ArrowExpr {
+    #[doc = "Calls [Fold`::fold_arrow_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_arrow_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ArrowExpr {
                 span,
@@ -124776,63 +101629,15 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrowExpr {
                 type_params,
                 return_type,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
-                        self::fields::ArrowExprField::Params(usize::MAX),
-                    ));
-                    <Vec<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Body));
-                    <Box<BlockStmtOrExpr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let params = { <Vec<Pat> as FoldWith<V>>::fold_with(params, visitor) };
+                let body = { <Box<BlockStmtOrExpr> as FoldWith<V>>::fold_with(body, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
-                        self::fields::ArrowExprField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let return_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
-                        self::fields::ArrowExprField::ReturnType,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        return_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
+                let return_type =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(return_type, visitor) };
                 ArrowExpr {
                     span,
                     ctxt,
@@ -124847,15 +101652,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrowExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignExpr {
-    #[doc = "Calls [FoldAstPath`::fold_assign_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_assign_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AssignExpr {
+    #[doc = "Calls [Fold`::fold_assign_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_assign_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AssignExpr {
                 span,
@@ -124863,45 +101666,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignExpr {
                 left,
                 right,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
-                        self::fields::AssignExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let op = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AssignExpr(self::fields::AssignExprField::Op));
-                    <AssignOp as FoldWithAstPath<V>>::fold_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
-                        self::fields::AssignExprField::Left,
-                    ));
-                    <AssignTarget as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
-                        self::fields::AssignExprField::Right,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let op = { <AssignOp as FoldWith<V>>::fold_with(op, visitor) };
+                let left = { <AssignTarget as FoldWith<V>>::fold_with(left, visitor) };
+                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
                 AssignExpr {
                     span,
                     op,
@@ -124912,15 +101680,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignOp {
-    #[doc = "Calls [FoldAstPath`::fold_assign_op`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_assign_op(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AssignOp {
+    #[doc = "Calls [Fold`::fold_assign_op`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_assign_op(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AssignOp::Assign => AssignOp::Assign,
             AssignOp::AddAssign => AssignOp::AddAssign,
@@ -124941,232 +101707,106 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignPat {
-    #[doc = "Calls [FoldAstPath`::fold_assign_pat`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_assign_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AssignPat {
+    #[doc = "Calls [Fold`::fold_assign_pat`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_assign_pat(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AssignPat { span, left, right } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Left));
-                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPat(
-                        self::fields::AssignPatField::Right,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <Box<Pat> as FoldWith<V>>::fold_with(left, visitor) };
+                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
                 AssignPat { span, left, right }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignPatProp {
-    #[doc = "Calls [FoldAstPath`::fold_assign_pat_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_assign_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AssignPatProp {
+    #[doc = "Calls [Fold`::fold_assign_pat_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_assign_pat_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AssignPatProp { span, key, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
-                        self::fields::AssignPatPropField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
-                        self::fields::AssignPatPropField::Key,
-                    ));
-                    <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
-                        self::fields::AssignPatPropField::Value,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <BindingIdent as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
                 AssignPatProp { span, key, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignProp {
-    #[doc = "Calls [FoldAstPath`::fold_assign_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_assign_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AssignProp {
+    #[doc = "Calls [Fold`::fold_assign_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_assign_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AssignProp { span, key, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
-                        self::fields::AssignPropField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
-                        self::fields::AssignPropField::Key,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
-                        self::fields::AssignPropField::Value,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <Ident as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Box<Expr> as FoldWith<V>>::fold_with(value, visitor) };
                 AssignProp { span, key, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignTarget {
-    #[doc = "Calls [FoldAstPath`::fold_assign_target`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_assign_target(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AssignTarget {
+    #[doc = "Calls [Fold`::fold_assign_target`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_assign_target(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AssignTarget::Simple { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
-                    self::fields::AssignTargetField::Simple,
-                ));
-                let _field_0 = <SimpleAssignTarget as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SimpleAssignTarget as FoldWith<V>>::fold_with(_field_0, visitor);
                 AssignTarget::Simple { 0: _field_0 }
             }
             AssignTarget::Pat { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
-                    self::fields::AssignTargetField::Pat,
-                ));
-                let _field_0 = <AssignTargetPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AssignTargetPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 AssignTarget::Pat { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignTargetPat {
-    #[doc = "Calls [FoldAstPath`::fold_assign_target_pat`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_assign_target_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AssignTargetPat {
+    #[doc = "Calls [Fold`::fold_assign_target_pat`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_assign_target_pat(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AssignTargetPat::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
-                    self::fields::AssignTargetPatField::Array,
-                ));
-                let _field_0 = <ArrayPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ArrayPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 AssignTargetPat::Array { 0: _field_0 }
             }
             AssignTargetPat::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
-                    self::fields::AssignTargetPatField::Object,
-                ));
-                let _field_0 = <ObjectPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ObjectPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 AssignTargetPat::Object { 0: _field_0 }
             }
             AssignTargetPat::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
-                    self::fields::AssignTargetPatField::Invalid,
-                ));
-                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
                 AssignTargetPat::Invalid { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AutoAccessor {
-    #[doc = "Calls [FoldAstPath`::fold_auto_accessor`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_auto_accessor(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AutoAccessor {
+    #[doc = "Calls [Fold`::fold_auto_accessor`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_auto_accessor(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AutoAccessor {
                 span,
@@ -125180,62 +101820,15 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AutoAccessor {
                 is_override,
                 definite,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Key,
-                    ));
-                    <Key as FoldWithAstPath<V>>::fold_with_ast_path(key, visitor, &mut *__ast_path)
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Value,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decorators = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let accessibility = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
-                        self::fields::AutoAccessorField::Accessibility,
-                    ));
-                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <Key as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
+                let decorators =
+                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
+                let accessibility =
+                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
                 AutoAccessor {
                     span,
                     key,
@@ -125252,92 +101845,46 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AutoAccessor {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AwaitExpr {
-    #[doc = "Calls [FoldAstPath`::fold_await_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_await_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for AwaitExpr {
+    #[doc = "Calls [Fold`::fold_await_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_await_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             AwaitExpr { span, arg } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Arg));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
                 AwaitExpr { span, arg }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BigInt {
-    #[doc = "Calls [FoldAstPath`::fold_big_int`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_big_int(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BigInt {
+    #[doc = "Calls [Fold`::fold_big_int`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_big_int(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BigInt { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Value));
-                    <Box<BigIntValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <Box<BigIntValue> as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 BigInt { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinExpr {
-    #[doc = "Calls [FoldAstPath`::fold_bin_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_bin_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BinExpr {
+    #[doc = "Calls [Fold`::fold_bin_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_bin_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BinExpr {
                 span,
@@ -125345,42 +101892,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinExpr {
                 left,
                 right,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let op = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Op));
-                    <BinaryOp as FoldWithAstPath<V>>::fold_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Left));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Right));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let op = { <BinaryOp as FoldWith<V>>::fold_with(op, visitor) };
+                let left = { <Box<Expr> as FoldWith<V>>::fold_with(left, visitor) };
+                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
                 BinExpr {
                     span,
                     op,
@@ -125391,15 +101906,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinaryOp {
-    #[doc = "Calls [FoldAstPath`::fold_binary_op`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_binary_op(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BinaryOp {
+    #[doc = "Calls [Fold`::fold_binary_op`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_binary_op(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BinaryOp::EqEq => BinaryOp::EqEq,
             BinaryOp::NotEq => BinaryOp::NotEq,
@@ -125429,186 +101942,97 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinaryOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BindingIdent {
-    #[doc = "Calls [FoldAstPath`::fold_binding_ident`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_binding_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BindingIdent {
+    #[doc = "Calls [Fold`::fold_binding_ident`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_binding_ident(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BindingIdent { id, type_ann } => {
-                let id = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
-                        self::fields::BindingIdentField::Id,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
-                        self::fields::BindingIdentField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 BindingIdent { id, type_ann }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BlockStmt {
-    #[doc = "Calls [FoldAstPath`::fold_block_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_block_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BlockStmt {
+    #[doc = "Calls [Fold`::fold_block_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_block_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BlockStmt { span, ctxt, stmts } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let stmts = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmt(
-                        self::fields::BlockStmtField::Stmts(usize::MAX),
-                    ));
-                    <Vec<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        stmts,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let stmts = { <Vec<Stmt> as FoldWith<V>>::fold_with(stmts, visitor) };
                 BlockStmt { span, ctxt, stmts }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BlockStmtOrExpr {
-    #[doc = "Calls [FoldAstPath`::fold_block_stmt_or_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_block_stmt_or_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BlockStmtOrExpr {
+    #[doc = "Calls [Fold`::fold_block_stmt_or_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_block_stmt_or_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BlockStmtOrExpr::BlockStmt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
-                    self::fields::BlockStmtOrExprField::BlockStmt,
-                ));
-                let _field_0 = <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BlockStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 BlockStmtOrExpr::BlockStmt { 0: _field_0 }
             }
             BlockStmtOrExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
-                    self::fields::BlockStmtOrExprField::Expr,
-                ));
-                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
                 BlockStmtOrExpr::Expr { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Bool {
-    #[doc = "Calls [FoldAstPath`::fold_bool`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_bool(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Bool {
+    #[doc = "Calls [Fold`::fold_bool`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_bool(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Bool { span, value } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Bool(self::fields::BoolField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 Bool { span, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BreakStmt {
-    #[doc = "Calls [FoldAstPath`::fold_break_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_break_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for BreakStmt {
+    #[doc = "Calls [Fold`::fold_break_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_break_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             BreakStmt { span, label } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::BreakStmt(self::fields::BreakStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let label = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BreakStmt(
-                        self::fields::BreakStmtField::Label,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let label = { <Option<Ident> as FoldWith<V>>::fold_with(label, visitor) };
                 BreakStmt { span, label }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CallExpr {
-    #[doc = "Calls [FoldAstPath`::fold_call_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_call_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CallExpr {
+    #[doc = "Calls [Fold`::fold_call_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_call_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CallExpr {
                 span,
@@ -125617,48 +102041,14 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CallExpr {
                 args,
                 type_args,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let callee = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Callee));
-                    <Callee as FoldWithAstPath<V>>::fold_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
-                        self::fields::CallExprField::Args(usize::MAX),
-                    ));
-                    <Vec<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let callee = { <Callee as FoldWith<V>>::fold_with(callee, visitor) };
+                let args = { <Vec<ExprOrSpread> as FoldWith<V>>::fold_with(args, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
-                        self::fields::CallExprField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_args, visitor,
+                    )
                 };
                 CallExpr {
                     span,
@@ -125671,104 +102061,53 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CallExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Callee {
-    #[doc = "Calls [FoldAstPath`::fold_callee`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_callee(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Callee {
+    #[doc = "Calls [Fold`::fold_callee`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_callee(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Callee::Super { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Super));
-                let _field_0 = <Super as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Super as FoldWith<V>>::fold_with(_field_0, visitor);
                 Callee::Super { 0: _field_0 }
             }
             Callee::Import { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Import));
-                let _field_0 = <Import as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Import as FoldWith<V>>::fold_with(_field_0, visitor);
                 Callee::Import { 0: _field_0 }
             }
             Callee::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Expr));
-                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Callee::Expr { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CatchClause {
-    #[doc = "Calls [FoldAstPath`::fold_catch_clause`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_catch_clause(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CatchClause {
+    #[doc = "Calls [Fold`::fold_catch_clause`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_catch_clause(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CatchClause { span, param, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
-                        self::fields::CatchClauseField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let param = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
-                        self::fields::CatchClauseField::Param,
-                    ));
-                    <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
-                        self::fields::CatchClauseField::Body,
-                    ));
-                    <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let param = { <Option<Pat> as FoldWith<V>>::fold_with(param, visitor) };
+                let body = { <BlockStmt as FoldWith<V>>::fold_with(body, visitor) };
                 CatchClause { span, param, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Class {
-    #[doc = "Calls [FoldAstPath`::fold_class`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Class {
+    #[doc = "Calls [Fold`::fold_class`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Class {
                 span,
@@ -125781,78 +102120,24 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Class {
                 super_type_params,
                 implements,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decorators = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::Body(usize::MAX),
-                    ));
-                    <Vec<ClassMember> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let super_class = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Class(self::fields::ClassField::SuperClass));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        super_class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let decorators =
+                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
+                let body = { <Vec<ClassMember> as FoldWith<V>>::fold_with(body, visitor) };
+                let super_class =
+                    { <Option<Box<Expr>> as FoldWith<V>>::fold_with(super_class, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Class(self::fields::ClassField::TypeParams));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
                 let super_type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::SuperTypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (super_type_params , visitor , & mut * __ast_path)
-                };
-                let implements = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
-                        self::fields::ClassField::Implements(usize::MAX),
-                    ));
-                    <Vec<TsExprWithTypeArgs> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        implements,
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        super_type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                let implements =
+                    { <Vec<TsExprWithTypeArgs> as FoldWith<V>>::fold_with(implements, visitor) };
                 Class {
                     span,
                     ctxt,
@@ -125868,207 +102153,100 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Class {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassDecl {
-    #[doc = "Calls [FoldAstPath`::fold_class_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ClassDecl {
+    #[doc = "Calls [Fold`::fold_class_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ClassDecl {
                 ident,
                 declare,
                 class,
             } => {
-                let ident = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
-                        self::fields::ClassDeclField::Ident,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let class = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
-                        self::fields::ClassDeclField::Class,
-                    ));
-                    <Box<Class> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let ident = { <Ident as FoldWith<V>>::fold_with(ident, visitor) };
+                let class = { <Box<Class> as FoldWith<V>>::fold_with(class, visitor) };
                 ClassDecl {
                     ident,
                     declare,
                     class,
                 }
             }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassExpr {
-    #[doc = "Calls [FoldAstPath`::fold_class_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class_expr(visitor, self, __ast_path)
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for ClassExpr {
+    #[doc = "Calls [Fold`::fold_class_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ClassExpr { ident, class } => {
-                let ident = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
-                        self::fields::ClassExprField::Ident,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let class = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
-                        self::fields::ClassExprField::Class,
-                    ));
-                    <Box<Class> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        class,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let ident = { <Option<Ident> as FoldWith<V>>::fold_with(ident, visitor) };
+                let class = { <Box<Class> as FoldWith<V>>::fold_with(class, visitor) };
                 ClassExpr { ident, class }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassMember {
-    #[doc = "Calls [FoldAstPath`::fold_class_member`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class_member(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ClassMember {
+    #[doc = "Calls [Fold`::fold_class_member`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class_member(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ClassMember::Constructor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::Constructor,
-                ));
-                let _field_0 = <Constructor as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Constructor as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::Constructor { 0: _field_0 }
             }
             ClassMember::Method { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::Method,
-                ));
-                let _field_0 = <ClassMethod as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ClassMethod as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::Method { 0: _field_0 }
             }
             ClassMember::PrivateMethod { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::PrivateMethod,
-                ));
-                let _field_0 = <PrivateMethod as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PrivateMethod as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::PrivateMethod { 0: _field_0 }
             }
             ClassMember::ClassProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::ClassProp,
-                ));
-                let _field_0 = <ClassProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ClassProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::ClassProp { 0: _field_0 }
             }
             ClassMember::PrivateProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::PrivateProp,
-                ));
-                let _field_0 = <PrivateProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PrivateProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::PrivateProp { 0: _field_0 }
             }
             ClassMember::TsIndexSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::TsIndexSignature,
-                ));
-                let _field_0 = <TsIndexSignature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsIndexSignature as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::TsIndexSignature { 0: _field_0 }
             }
             ClassMember::Empty { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::Empty,
-                ));
-                let _field_0 = <EmptyStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <EmptyStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::Empty { 0: _field_0 }
             }
             ClassMember::StaticBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::StaticBlock,
-                ));
-                let _field_0 = <StaticBlock as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <StaticBlock as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::StaticBlock { 0: _field_0 }
             }
             ClassMember::AutoAccessor { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
-                    self::fields::ClassMemberField::AutoAccessor,
-                ));
-                let _field_0 = <AutoAccessor as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AutoAccessor as FoldWith<V>>::fold_with(_field_0, visitor);
                 ClassMember::AutoAccessor { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassMethod {
-    #[doc = "Calls [FoldAstPath`::fold_class_method`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class_method(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ClassMethod {
+    #[doc = "Calls [Fold`::fold_class_method`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class_method(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ClassMethod {
                 span,
@@ -126081,56 +102259,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassMethod {
                 is_optional,
                 is_override,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Key,
-                    ));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let function = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Function,
-                    ));
-                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let kind = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Kind,
-                    ));
-                    <MethodKind as FoldWithAstPath<V>>::fold_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let accessibility = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
-                        self::fields::ClassMethodField::Accessibility,
-                    ));
-                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
+                let kind = { <MethodKind as FoldWith<V>>::fold_with(kind, visitor) };
+                let accessibility =
+                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
                 ClassMethod {
                     span,
                     key,
@@ -126146,15 +102280,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassMethod {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassProp {
-    #[doc = "Calls [FoldAstPath`::fold_class_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ClassProp {
+    #[doc = "Calls [Fold`::fold_class_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ClassProp {
                 span,
@@ -126171,64 +102303,15 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassProp {
                 declare,
                 definite,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Key));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::Value,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decorators = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let accessibility = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
-                        self::fields::ClassPropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
+                let decorators =
+                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
+                let accessibility =
+                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
                 ClassProp {
                     span,
                     key,
@@ -126248,51 +102331,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassProp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComputedPropName {
-    #[doc = "Calls [FoldAstPath`::fold_computed_prop_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_computed_prop_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ComputedPropName {
+    #[doc = "Calls [Fold`::fold_computed_prop_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_computed_prop_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ComputedPropName { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
-                        self::fields::ComputedPropNameField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
-                        self::fields::ComputedPropNameField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 ComputedPropName { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CondExpr {
-    #[doc = "Calls [FoldAstPath`::fold_cond_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_cond_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for CondExpr {
+    #[doc = "Calls [Fold`::fold_cond_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_cond_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             CondExpr {
                 span,
@@ -126300,42 +102361,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CondExpr {
                 cons,
                 alt,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let test = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Test));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let cons = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Cons));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let alt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Alt));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        alt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
+                let cons = { <Box<Expr> as FoldWith<V>>::fold_with(cons, visitor) };
+                let alt = { <Box<Expr> as FoldWith<V>>::fold_with(alt, visitor) };
                 CondExpr {
                     span,
                     test,
@@ -126346,15 +102375,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CondExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Constructor {
-    #[doc = "Calls [FoldAstPath`::fold_constructor`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_constructor(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Constructor {
+    #[doc = "Calls [Fold`::fold_constructor`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_constructor(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Constructor {
                 span,
@@ -126365,66 +102392,14 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Constructor {
                 accessibility,
                 is_optional,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Key,
-                    ));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Params(usize::MAX),
-                    ));
-                    <Vec<ParamOrTsParamProp> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Body,
-                    ));
-                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let accessibility = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
-                        self::fields::ConstructorField::Accessibility,
-                    ));
-                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let params =
+                    { <Vec<ParamOrTsParamProp> as FoldWith<V>>::fold_with(params, visitor) };
+                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
+                let accessibility =
+                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
                 Constructor {
                     span,
                     ctxt,
@@ -126438,321 +102413,158 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Constructor {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContinueStmt {
-    #[doc = "Calls [FoldAstPath`::fold_continue_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_continue_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ContinueStmt {
+    #[doc = "Calls [Fold`::fold_continue_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_continue_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ContinueStmt { span, label } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
-                        self::fields::ContinueStmtField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let label = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
-                        self::fields::ContinueStmtField::Label,
-                    ));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let label = { <Option<Ident> as FoldWith<V>>::fold_with(label, visitor) };
                 ContinueStmt { span, label }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DebuggerStmt {
-    #[doc = "Calls [FoldAstPath`::fold_debugger_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_debugger_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DebuggerStmt {
+    #[doc = "Calls [Fold`::fold_debugger_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_debugger_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DebuggerStmt { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DebuggerStmt(
-                        self::fields::DebuggerStmtField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 DebuggerStmt { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Decl {
-    #[doc = "Calls [FoldAstPath`::fold_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Decl {
+    #[doc = "Calls [Fold`::fold_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Decl::Class { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Class));
-                let _field_0 = <ClassDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ClassDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::Class { 0: _field_0 }
             }
             Decl::Fn { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Fn));
-                let _field_0 = <FnDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <FnDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::Fn { 0: _field_0 }
             }
             Decl::Var { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Var));
-                let _field_0 = <Box<VarDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<VarDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::Var { 0: _field_0 }
             }
             Decl::Using { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Using));
-                let _field_0 = <Box<UsingDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<UsingDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::Using { 0: _field_0 }
             }
             Decl::TsInterface { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsInterface));
-                let _field_0 = <Box<TsInterfaceDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TsInterfaceDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::TsInterface { 0: _field_0 }
             }
             Decl::TsTypeAlias { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsTypeAlias));
-                let _field_0 = <Box<TsTypeAliasDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TsTypeAliasDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::TsTypeAlias { 0: _field_0 }
             }
             Decl::TsEnum { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsEnum));
-                let _field_0 = <Box<TsEnumDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TsEnumDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::TsEnum { 0: _field_0 }
             }
             Decl::TsModule { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsModule));
-                let _field_0 = <Box<TsModuleDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TsModuleDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Decl::TsModule { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Decorator {
-    #[doc = "Calls [FoldAstPath`::fold_decorator`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_decorator(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Decorator {
+    #[doc = "Calls [Fold`::fold_decorator`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_decorator(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Decorator { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Expr));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 Decorator { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DefaultDecl {
-    #[doc = "Calls [FoldAstPath`::fold_default_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_default_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DefaultDecl {
+    #[doc = "Calls [Fold`::fold_default_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_default_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DefaultDecl::Class { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
-                    self::fields::DefaultDeclField::Class,
-                ));
-                let _field_0 = <ClassExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ClassExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 DefaultDecl::Class { 0: _field_0 }
             }
             DefaultDecl::Fn { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
-                    self::fields::DefaultDeclField::Fn,
-                ));
-                let _field_0 = <FnExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <FnExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 DefaultDecl::Fn { 0: _field_0 }
             }
             DefaultDecl::TsInterfaceDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
-                    self::fields::DefaultDeclField::TsInterfaceDecl,
-                ));
-                let _field_0 = <Box<TsInterfaceDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TsInterfaceDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 DefaultDecl::TsInterfaceDecl { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DoWhileStmt {
-    #[doc = "Calls [FoldAstPath`::fold_do_while_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_do_while_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for DoWhileStmt {
+    #[doc = "Calls [Fold`::fold_do_while_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_do_while_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             DoWhileStmt { span, test, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
-                        self::fields::DoWhileStmtField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let test = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
-                        self::fields::DoWhileStmtField::Test,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
-                        self::fields::DoWhileStmtField::Body,
-                    ));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
+                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
                 DoWhileStmt { span, test, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for EmptyStmt {
-    #[doc = "Calls [FoldAstPath`::fold_empty_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_empty_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for EmptyStmt {
+    #[doc = "Calls [Fold`::fold_empty_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_empty_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             EmptyStmt { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::EmptyStmt(self::fields::EmptyStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 EmptyStmt { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for EsVersion {
-    #[doc = "Calls [FoldAstPath`::fold_es_version`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_es_version(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for EsVersion {
+    #[doc = "Calls [Fold`::fold_es_version`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_es_version(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             EsVersion::Es3 => EsVersion::Es3,
             EsVersion::Es5 => EsVersion::Es5,
@@ -126768,15 +102580,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for EsVersion {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportAll {
-    #[doc = "Calls [FoldAstPath`::fold_export_all`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_all(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportAll {
+    #[doc = "Calls [Fold`::fold_export_all`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_all(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportAll {
                 span,
@@ -126784,33 +102594,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportAll {
                 type_only,
                 with,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let src = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Src));
-                    <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let with = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::With));
-                    <Option<Box<ObjectLit>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let src = { <Box<Str> as FoldWith<V>>::fold_with(src, visitor) };
+                let with = { <Option<Box<ObjectLit>> as FoldWith<V>>::fold_with(with, visitor) };
                 ExportAll {
                     span,
                     src,
@@ -126821,150 +102607,76 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportAll {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDecl {
-    #[doc = "Calls [FoldAstPath`::fold_export_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportDecl {
+    #[doc = "Calls [Fold`::fold_export_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportDecl { span, decl } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
-                        self::fields::ExportDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decl = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
-                        self::fields::ExportDeclField::Decl,
-                    ));
-                    <Decl as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decl,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let decl = { <Decl as FoldWith<V>>::fold_with(decl, visitor) };
                 ExportDecl { span, decl }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDefaultDecl {
-    #[doc = "Calls [FoldAstPath`::fold_export_default_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_default_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportDefaultDecl {
+    #[doc = "Calls [Fold`::fold_export_default_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_default_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportDefaultDecl { span, decl } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
-                        self::fields::ExportDefaultDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decl = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
-                        self::fields::ExportDefaultDeclField::Decl,
-                    ));
-                    <DefaultDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decl,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let decl = { <DefaultDecl as FoldWith<V>>::fold_with(decl, visitor) };
                 ExportDefaultDecl { span, decl }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDefaultExpr {
-    #[doc = "Calls [FoldAstPath`::fold_export_default_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_default_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportDefaultExpr {
+    #[doc = "Calls [Fold`::fold_export_default_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_default_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportDefaultExpr { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
-                        self::fields::ExportDefaultExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
-                        self::fields::ExportDefaultExprField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 ExportDefaultExpr { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDefaultSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_export_default_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_default_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportDefaultSpecifier {
+    #[doc = "Calls [Fold`::fold_export_default_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_default_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportDefaultSpecifier { exported } => {
-                let exported = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportDefaultSpecifier(
-                            self::fields::ExportDefaultSpecifierField::Exported,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        exported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let exported = { <Ident as FoldWith<V>>::fold_with(exported, visitor) };
                 ExportDefaultSpecifier { exported }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportNamedSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_export_named_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_named_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportNamedSpecifier {
+    #[doc = "Calls [Fold`::fold_export_named_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_named_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportNamedSpecifier {
                 span,
@@ -126972,39 +102684,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportNamedSpecifier {
                 exported,
                 is_type_only,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
-                            self::fields::ExportNamedSpecifierField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let orig = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
-                            self::fields::ExportNamedSpecifierField::Orig,
-                        ));
-                    <ModuleExportName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        orig,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let exported = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
-                            self::fields::ExportNamedSpecifierField::Exported,
-                        ));
-                    <Option<ModuleExportName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        exported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let orig = { <ModuleExportName as FoldWith<V>>::fold_with(orig, visitor) };
+                let exported =
+                    { <Option<ModuleExportName> as FoldWith<V>>::fold_with(exported, visitor) };
                 ExportNamedSpecifier {
                     span,
                     orig,
@@ -127015,590 +102698,258 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportNamedSpecifier {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportNamespaceSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_export_namespace_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_namespace_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportNamespaceSpecifier {
+    #[doc = "Calls [Fold`::fold_export_namespace_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_namespace_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportNamespaceSpecifier { span, name } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
-                            self::fields::ExportNamespaceSpecifierField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
-                            self::fields::ExportNamespaceSpecifierField::Name,
-                        ));
-                    <ModuleExportName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <ModuleExportName as FoldWith<V>>::fold_with(name, visitor) };
                 ExportNamespaceSpecifier { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_export_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExportSpecifier {
+    #[doc = "Calls [Fold`::fold_export_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExportSpecifier::Namespace { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
-                    self::fields::ExportSpecifierField::Namespace,
-                ));
-                let _field_0 = <ExportNamespaceSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <ExportNamespaceSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
                 ExportSpecifier::Namespace { 0: _field_0 }
             }
             ExportSpecifier::Default { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
-                    self::fields::ExportSpecifierField::Default,
-                ));
-                let _field_0 = <ExportDefaultSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <ExportDefaultSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
                 ExportSpecifier::Default { 0: _field_0 }
             }
             ExportSpecifier::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
-                    self::fields::ExportSpecifierField::Named,
-                ));
-                let _field_0 = <ExportNamedSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ExportNamedSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
                 ExportSpecifier::Named { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Expr {
-    #[doc = "Calls [FoldAstPath`::fold_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Expr {
+    #[doc = "Calls [Fold`::fold_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Expr::This { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::This));
-                let _field_0 = <ThisExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ThisExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::This { 0: _field_0 }
             }
             Expr::Array { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Array));
-                let _field_0 = <ArrayLit as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ArrayLit as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Array { 0: _field_0 }
             }
             Expr::Object { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Object));
-                let _field_0 = <ObjectLit as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ObjectLit as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Object { 0: _field_0 }
             }
             Expr::Fn { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Fn));
-                let _field_0 = <FnExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <FnExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Fn { 0: _field_0 }
             }
             Expr::Unary { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Unary));
-                let _field_0 = <UnaryExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <UnaryExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Unary { 0: _field_0 }
             }
             Expr::Update { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Update));
-                let _field_0 = <UpdateExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <UpdateExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Update { 0: _field_0 }
             }
             Expr::Bin { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Bin));
-                let _field_0 = <BinExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BinExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Bin { 0: _field_0 }
             }
             Expr::Assign { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Assign));
-                let _field_0 = <AssignExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AssignExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Assign { 0: _field_0 }
             }
             Expr::Member { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Member));
-                let _field_0 = <MemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Member { 0: _field_0 }
             }
             Expr::SuperProp { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::SuperProp));
-                let _field_0 = <SuperPropExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SuperPropExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::SuperProp { 0: _field_0 }
             }
             Expr::Cond { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Cond));
-                let _field_0 = <CondExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CondExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Cond { 0: _field_0 }
             }
             Expr::Call { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Call));
-                let _field_0 = <CallExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <CallExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Call { 0: _field_0 }
             }
             Expr::New { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::New));
-                let _field_0 = <NewExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <NewExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::New { 0: _field_0 }
             }
             Expr::Seq { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Seq));
-                let _field_0 = <SeqExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SeqExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Seq { 0: _field_0 }
             }
             Expr::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Ident));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Ident { 0: _field_0 }
             }
             Expr::Lit { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Lit));
-                let _field_0 = <Lit as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Lit as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Lit { 0: _field_0 }
             }
             Expr::Tpl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Tpl));
-                let _field_0 = <Tpl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Tpl as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Tpl { 0: _field_0 }
             }
             Expr::TaggedTpl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TaggedTpl));
-                let _field_0 = <TaggedTpl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TaggedTpl as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::TaggedTpl { 0: _field_0 }
             }
             Expr::Arrow { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Arrow));
-                let _field_0 = <ArrowExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ArrowExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Arrow { 0: _field_0 }
             }
             Expr::Class { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Class));
-                let _field_0 = <ClassExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ClassExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Class { 0: _field_0 }
             }
             Expr::Yield { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Yield));
-                let _field_0 = <YieldExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <YieldExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Yield { 0: _field_0 }
             }
             Expr::MetaProp { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::MetaProp));
-                let _field_0 = <MetaPropExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MetaPropExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::MetaProp { 0: _field_0 }
             }
             Expr::Await { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Await));
-                let _field_0 = <AwaitExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AwaitExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Await { 0: _field_0 }
             }
             Expr::Paren { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Paren));
-                let _field_0 = <ParenExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ParenExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Paren { 0: _field_0 }
             }
             Expr::JSXMember { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxmember));
-                let _field_0 = <JSXMemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXMemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::JSXMember { 0: _field_0 }
             }
             Expr::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::JsxnamespacedName,
-                ));
-                let _field_0 = <JSXNamespacedName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXNamespacedName as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::JSXNamespacedName { 0: _field_0 }
             }
             Expr::JSXEmpty { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxempty));
-                let _field_0 = <JSXEmptyExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXEmptyExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::JSXEmpty { 0: _field_0 }
             }
             Expr::JSXElement { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxelement));
-                let _field_0 = <Box<JSXElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<JSXElement> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::JSXElement { 0: _field_0 }
             }
             Expr::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxfragment));
-                let _field_0 = <JSXFragment as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXFragment as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::JSXFragment { 0: _field_0 }
             }
             Expr::TsTypeAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::TsTypeAssertion,
-                ));
-                let _field_0 = <TsTypeAssertion as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTypeAssertion as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::TsTypeAssertion { 0: _field_0 }
             }
             Expr::TsConstAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::TsConstAssertion,
-                ));
-                let _field_0 = <TsConstAssertion as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsConstAssertion as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::TsConstAssertion { 0: _field_0 }
             }
             Expr::TsNonNull { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsNonNull));
-                let _field_0 = <TsNonNullExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsNonNullExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::TsNonNull { 0: _field_0 }
             }
             Expr::TsAs { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsAs));
-                let _field_0 = <TsAsExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsAsExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::TsAs { 0: _field_0 }
             }
             Expr::TsInstantiation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
-                    self::fields::ExprField::TsInstantiation,
-                ));
-                let _field_0 = <TsInstantiation as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsInstantiation as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::TsInstantiation { 0: _field_0 }
             }
             Expr::TsSatisfies { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Expr(self::fields::ExprField::TsSatisfies));
-                let _field_0 = <TsSatisfiesExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsSatisfiesExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::TsSatisfies { 0: _field_0 }
             }
             Expr::PrivateName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Expr(self::fields::ExprField::PrivateName));
-                let _field_0 = <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PrivateName as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::PrivateName { 0: _field_0 }
             }
             Expr::OptChain { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::OptChain));
-                let _field_0 = <OptChainExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <OptChainExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::OptChain { 0: _field_0 }
             }
             Expr::Invalid { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Invalid));
-                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
                 Expr::Invalid { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExprOrSpread {
-    #[doc = "Calls [FoldAstPath`::fold_expr_or_spread`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_expr_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExprOrSpread {
+    #[doc = "Calls [Fold`::fold_expr_or_spread`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_expr_or_spread(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExprOrSpread { spread, expr } => {
-                let spread = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
-                        self::fields::ExprOrSpreadField::Spread,
-                    ));
-                    <Option<swc_common::Span> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        spread,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
-                        self::fields::ExprOrSpreadField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let spread =
+                    { <Option<swc_common::Span> as FoldWith<V>>::fold_with(spread, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 ExprOrSpread { spread, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExprStmt {
-    #[doc = "Calls [FoldAstPath`::fold_expr_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_expr_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ExprStmt {
+    #[doc = "Calls [Fold`::fold_expr_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_expr_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ExprStmt { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Expr));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 ExprStmt { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FnDecl {
-    #[doc = "Calls [FoldAstPath`::fold_fn_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_fn_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for FnDecl {
+    #[doc = "Calls [Fold`::fold_fn_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_fn_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             FnDecl {
                 ident,
                 declare,
                 function,
             } => {
-                let ident = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Ident));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let function = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Function));
-                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let ident = { <Ident as FoldWith<V>>::fold_with(ident, visitor) };
+                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
                 FnDecl {
                     ident,
                     declare,
@@ -127608,93 +102959,52 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FnDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FnExpr {
-    #[doc = "Calls [FoldAstPath`::fold_fn_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_fn_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for FnExpr {
+    #[doc = "Calls [Fold`::fold_fn_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_fn_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             FnExpr { ident, function } => {
-                let ident = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Ident));
-                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ident,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let function = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Function));
-                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let ident = { <Option<Ident> as FoldWith<V>>::fold_with(ident, visitor) };
+                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
                 FnExpr { ident, function }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForHead {
-    #[doc = "Calls [FoldAstPath`::fold_for_head`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_for_head(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForHead {
+    #[doc = "Calls [Fold`::fold_for_head`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_for_head(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ForHead::VarDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::ForHead(self::fields::ForHeadField::VarDecl));
-                let _field_0 = <Box<VarDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<VarDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ForHead::VarDecl { 0: _field_0 }
             }
             ForHead::UsingDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ForHead(
-                    self::fields::ForHeadField::UsingDecl,
-                ));
-                let _field_0 = <Box<UsingDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<UsingDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ForHead::UsingDecl { 0: _field_0 }
             }
             ForHead::Pat { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::ForHead(self::fields::ForHeadField::Pat));
-                let _field_0 = <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Pat> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ForHead::Pat { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForInStmt {
-    #[doc = "Calls [FoldAstPath`::fold_for_in_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_for_in_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForInStmt {
+    #[doc = "Calls [Fold`::fold_for_in_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_for_in_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ForInStmt {
                 span,
@@ -127702,43 +103012,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForInStmt {
                 right,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Left));
-                    <ForHead as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForInStmt(
-                        self::fields::ForInStmtField::Right,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Body));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <ForHead as FoldWith<V>>::fold_with(left, visitor) };
+                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
+                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
                 ForInStmt {
                     span,
                     left,
@@ -127749,15 +103026,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForInStmt {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForOfStmt {
-    #[doc = "Calls [FoldAstPath`::fold_for_of_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_for_of_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForOfStmt {
+    #[doc = "Calls [Fold`::fold_for_of_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_for_of_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ForOfStmt {
                 span,
@@ -127766,43 +103041,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForOfStmt {
                 right,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Left));
-                    <ForHead as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForOfStmt(
-                        self::fields::ForOfStmtField::Right,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Body));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <ForHead as FoldWith<V>>::fold_with(left, visitor) };
+                let right = { <Box<Expr> as FoldWith<V>>::fold_with(right, visitor) };
+                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
                 ForOfStmt {
                     span,
                     is_await,
@@ -127814,15 +103056,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForOfStmt {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForStmt {
-    #[doc = "Calls [FoldAstPath`::fold_for_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_for_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ForStmt {
+    #[doc = "Calls [Fold`::fold_for_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_for_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ForStmt {
                 span,
@@ -127831,51 +103071,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForStmt {
                 update,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let init = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Init));
-                    <Option<VarDeclOrExpr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let test = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Test));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let update = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Update));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        update,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Body));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let init = { <Option<VarDeclOrExpr> as FoldWith<V>>::fold_with(init, visitor) };
+                let test = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(test, visitor) };
+                let update = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(update, visitor) };
+                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
                 ForStmt {
                     span,
                     init,
@@ -127887,15 +103087,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForStmt {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Function {
-    #[doc = "Calls [FoldAstPath`::fold_function`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_function(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Function {
+    #[doc = "Calls [Fold`::fold_function`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_function(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Function {
                 params,
@@ -127908,73 +103106,17 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Function {
                 type_params,
                 return_type,
             } => {
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::Params(usize::MAX),
-                    ));
-                    <Vec<Param> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decorators = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Body));
-                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let params = { <Vec<Param> as FoldWith<V>>::fold_with(params, visitor) };
+                let decorators =
+                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let return_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
-                        self::fields::FunctionField::ReturnType,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        return_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
+                let return_type =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(return_type, visitor) };
                 Function {
                     params,
                     decorators,
@@ -127990,15 +103132,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Function {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for GetterProp {
-    #[doc = "Calls [FoldAstPath`::fold_getter_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_getter_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for GetterProp {
+    #[doc = "Calls [Fold`::fold_getter_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_getter_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             GetterProp {
                 span,
@@ -128006,46 +103146,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for GetterProp {
                 type_ann,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::Key,
-                    ));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
-                        self::fields::GetterPropField::Body,
-                    ));
-                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
+                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
                 GetterProp {
                     span,
                     key,
@@ -128056,15 +103161,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for GetterProp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ident {
-    #[doc = "Calls [FoldAstPath`::fold_ident`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Ident {
+    #[doc = "Calls [Fold`::fold_ident`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ident(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Ident {
                 span,
@@ -128072,33 +103175,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ident {
                 sym,
                 optional,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let sym = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Sym));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        sym,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let sym = { <swc_atoms::Atom as FoldWith<V>>::fold_with(sym, visitor) };
                 Ident {
                     span,
                     ctxt,
@@ -128109,49 +103188,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ident {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for IdentName {
-    #[doc = "Calls [FoldAstPath`::fold_ident_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ident_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for IdentName {
+    #[doc = "Calls [Fold`::fold_ident_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ident_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             IdentName { span, sym } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let sym = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Sym));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        sym,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let sym = { <swc_atoms::Atom as FoldWith<V>>::fold_with(sym, visitor) };
                 IdentName { span, sym }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for IfStmt {
-    #[doc = "Calls [FoldAstPath`::fold_if_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_if_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for IfStmt {
+    #[doc = "Calls [Fold`::fold_if_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_if_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             IfStmt {
                 span,
@@ -128159,154 +103218,58 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for IfStmt {
                 cons,
                 alt,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let test = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Test));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let cons = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Cons));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let alt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Alt));
-                    <Option<Box<Stmt>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        alt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                IfStmt {
-                    span,
-                    test,
-                    cons,
-                    alt,
-                }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Import {
-    #[doc = "Calls [FoldAstPath`::fold_import`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            Import { span, phase } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Import(self::fields::ImportField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let phase = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Import(self::fields::ImportField::Phase));
-                    <ImportPhase as FoldWithAstPath<V>>::fold_with_ast_path(
-                        phase,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                Import { span, phase }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportDecl {
-    #[doc = "Calls [FoldAstPath`::fold_import_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_decl(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            ImportDecl {
-                span,
-                specifiers,
-                src,
-                type_only,
-                with,
-                phase,
-            } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let specifiers = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Specifiers(usize::MAX),
-                    ));
-                    <Vec<ImportSpecifier> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        specifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let src = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Src,
-                    ));
-                    <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let with = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::With,
-                    ));
-                    <Option<Box<ObjectLit>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let phase = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
-                        self::fields::ImportDeclField::Phase,
-                    ));
-                    <ImportPhase as FoldWithAstPath<V>>::fold_with_ast_path(
-                        phase,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
+                let cons = { <Box<Stmt> as FoldWith<V>>::fold_with(cons, visitor) };
+                let alt = { <Option<Box<Stmt>> as FoldWith<V>>::fold_with(alt, visitor) };
+                IfStmt {
+                    span,
+                    test,
+                    cons,
+                    alt,
+                }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for Import {
+    #[doc = "Calls [Fold`::fold_import`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            Import { span, phase } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let phase = { <ImportPhase as FoldWith<V>>::fold_with(phase, visitor) };
+                Import { span, phase }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for ImportDecl {
+    #[doc = "Calls [Fold`::fold_import_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_decl(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            ImportDecl {
+                span,
+                specifiers,
+                src,
+                type_only,
+                with,
+                phase,
+            } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let specifiers =
+                    { <Vec<ImportSpecifier> as FoldWith<V>>::fold_with(specifiers, visitor) };
+                let src = { <Box<Str> as FoldWith<V>>::fold_with(src, visitor) };
+                let with = { <Option<Box<ObjectLit>> as FoldWith<V>>::fold_with(with, visitor) };
+                let phase = { <ImportPhase as FoldWith<V>>::fold_with(phase, visitor) };
                 ImportDecl {
                     span,
                     specifiers,
@@ -128319,53 +103282,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportDefaultSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_import_default_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_default_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportDefaultSpecifier {
+    #[doc = "Calls [Fold`::fold_import_default_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_default_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportDefaultSpecifier { span, local } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
-                            self::fields::ImportDefaultSpecifierField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let local = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
-                            self::fields::ImportDefaultSpecifierField::Local,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let local = { <Ident as FoldWith<V>>::fold_with(local, visitor) };
                 ImportDefaultSpecifier { span, local }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportNamedSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_import_named_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_named_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportNamedSpecifier {
+    #[doc = "Calls [Fold`::fold_import_named_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_named_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportNamedSpecifier {
                 span,
@@ -128373,39 +103312,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportNamedSpecifier {
                 imported,
                 is_type_only,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
-                            self::fields::ImportNamedSpecifierField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let local = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
-                            self::fields::ImportNamedSpecifierField::Local,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let imported = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
-                            self::fields::ImportNamedSpecifierField::Imported,
-                        ));
-                    <Option<ModuleExportName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        imported,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let local = { <Ident as FoldWith<V>>::fold_with(local, visitor) };
+                let imported =
+                    { <Option<ModuleExportName> as FoldWith<V>>::fold_with(imported, visitor) };
                 ImportNamedSpecifier {
                     span,
                     local,
@@ -128416,15 +103326,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportNamedSpecifier {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportPhase {
-    #[doc = "Calls [FoldAstPath`::fold_import_phase`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_phase(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportPhase {
+    #[doc = "Calls [Fold`::fold_import_phase`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_phase(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportPhase::Evaluation => ImportPhase::Evaluation,
             ImportPhase::Source => ImportPhase::Source,
@@ -128432,428 +103340,213 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportPhase {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_import_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportSpecifier {
+    #[doc = "Calls [Fold`::fold_import_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportSpecifier::Named { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
-                    self::fields::ImportSpecifierField::Named,
-                ));
-                let _field_0 = <ImportNamedSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ImportNamedSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
                 ImportSpecifier::Named { 0: _field_0 }
             }
             ImportSpecifier::Default { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
-                    self::fields::ImportSpecifierField::Default,
-                ));
-                let _field_0 = <ImportDefaultSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <ImportDefaultSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
                 ImportSpecifier::Default { 0: _field_0 }
             }
             ImportSpecifier::Namespace { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
-                    self::fields::ImportSpecifierField::Namespace,
-                ));
-                let _field_0 = <ImportStarAsSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ImportStarAsSpecifier as FoldWith<V>>::fold_with(_field_0, visitor);
                 ImportSpecifier::Namespace { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportStarAsSpecifier {
-    #[doc = "Calls [FoldAstPath`::fold_import_star_as_specifier`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_star_as_specifier(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportStarAsSpecifier {
+    #[doc = "Calls [Fold`::fold_import_star_as_specifier`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_star_as_specifier(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportStarAsSpecifier { span, local } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
-                            self::fields::ImportStarAsSpecifierField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let local = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
-                            self::fields::ImportStarAsSpecifierField::Local,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        local,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let local = { <Ident as FoldWith<V>>::fold_with(local, visitor) };
                 ImportStarAsSpecifier { span, local }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportWith {
-    #[doc = "Calls [FoldAstPath`::fold_import_with`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_with(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportWith {
+    #[doc = "Calls [Fold`::fold_import_with`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_with(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportWith { span, values } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
-                        self::fields::ImportWithField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let values = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
-                        self::fields::ImportWithField::Values(usize::MAX),
-                    ));
-                    <Vec<ImportWithItem> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        values,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let values = { <Vec<ImportWithItem> as FoldWith<V>>::fold_with(values, visitor) };
                 ImportWith { span, values }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportWithItem {
-    #[doc = "Calls [FoldAstPath`::fold_import_with_item`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_with_item(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ImportWithItem {
+    #[doc = "Calls [Fold`::fold_import_with_item`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_with_item(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ImportWithItem { key, value } => {
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
-                        self::fields::ImportWithItemField::Key,
-                    ));
-                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
-                        self::fields::ImportWithItemField::Value,
-                    ));
-                    <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let key = { <IdentName as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Str as FoldWith<V>>::fold_with(value, visitor) };
                 ImportWithItem { key, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Invalid {
-    #[doc = "Calls [FoldAstPath`::fold_invalid`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_invalid(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Invalid {
+    #[doc = "Calls [Fold`::fold_invalid`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_invalid(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Invalid { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Invalid(self::fields::InvalidField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 Invalid { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttr {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_attr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_attr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXAttr {
+    #[doc = "Calls [Fold`::fold_jsx_attr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_attr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXAttr { span, name, value } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Name));
-                    <JSXAttrName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Value));
-                    <Option<JSXAttrValue> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <JSXAttrName as FoldWith<V>>::fold_with(name, visitor) };
+                let value = { <Option<JSXAttrValue> as FoldWith<V>>::fold_with(value, visitor) };
                 JSXAttr { span, name, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttrName {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_attr_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXAttrName {
+    #[doc = "Calls [Fold`::fold_jsx_attr_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_attr_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXAttrName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
-                    self::fields::JSXAttrNameField::Ident,
-                ));
-                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrName::Ident { 0: _field_0 }
             }
             JSXAttrName::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
-                    self::fields::JSXAttrNameField::JsxnamespacedName,
-                ));
-                let _field_0 = <JSXNamespacedName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXNamespacedName as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrName::JSXNamespacedName { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttrOrSpread {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_or_spread`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_attr_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXAttrOrSpread {
+    #[doc = "Calls [Fold`::fold_jsx_attr_or_spread`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_attr_or_spread(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
-                    self::fields::JSXAttrOrSpreadField::Jsxattr,
-                ));
-                let _field_0 = <JSXAttr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXAttr as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrOrSpread::JSXAttr { 0: _field_0 }
             }
             JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
-                    self::fields::JSXAttrOrSpreadField::SpreadElement,
-                ));
-                let _field_0 = <SpreadElement as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SpreadElement as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrOrSpread::SpreadElement { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttrValue {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_value`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_attr_value(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXAttrValue {
+    #[doc = "Calls [Fold`::fold_jsx_attr_value`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_attr_value(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXAttrValue::Lit { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::Lit,
-                ));
-                let _field_0 = <Lit as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Lit as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrValue::Lit { 0: _field_0 }
             }
             JSXAttrValue::JSXExprContainer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::JsxexprContainer,
-                ));
-                let _field_0 = <JSXExprContainer as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXExprContainer as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrValue::JSXExprContainer { 0: _field_0 }
             }
             JSXAttrValue::JSXElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::Jsxelement,
-                ));
-                let _field_0 = <Box<JSXElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<JSXElement> as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrValue::JSXElement { 0: _field_0 }
             }
             JSXAttrValue::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
-                    self::fields::JSXAttrValueField::Jsxfragment,
-                ));
-                let _field_0 = <JSXFragment as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXFragment as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXAttrValue::JSXFragment { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXClosingElement {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_closing_element`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_closing_element(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXClosingElement {
+    #[doc = "Calls [Fold`::fold_jsx_closing_element`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_closing_element(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXClosingElement { span, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
-                        self::fields::JSXClosingElementField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
-                        self::fields::JSXClosingElementField::Name,
-                    ));
-                    <JSXElementName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <JSXElementName as FoldWith<V>>::fold_with(name, visitor) };
                 JSXClosingElement { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXClosingFragment {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_closing_fragment`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_closing_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXClosingFragment {
+    #[doc = "Calls [Fold`::fold_jsx_closing_fragment`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_closing_fragment(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXClosingFragment { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingFragment(
-                        self::fields::JSXClosingFragmentField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 JSXClosingFragment { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElement {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_element`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_element(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXElement {
+    #[doc = "Calls [Fold`::fold_jsx_element`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_element(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXElement {
                 span,
@@ -128861,46 +103554,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElement {
                 children,
                 closing,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let opening = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Opening,
-                    ));
-                    <JSXOpeningElement as FoldWithAstPath<V>>::fold_with_ast_path(
-                        opening,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let children = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Children(usize::MAX),
-                    ));
-                    <Vec<JSXElementChild> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let closing = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
-                        self::fields::JSXElementField::Closing,
-                    ));
-                    <Option<JSXClosingElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        closing,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let opening = { <JSXOpeningElement as FoldWith<V>>::fold_with(opening, visitor) };
+                let children =
+                    { <Vec<JSXElementChild> as FoldWith<V>>::fold_with(children, visitor) };
+                let closing =
+                    { <Option<JSXClosingElement> as FoldWith<V>>::fold_with(closing, visitor) };
                 JSXElement {
                     span,
                     opening,
@@ -128911,225 +103570,117 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElement {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElementChild {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_element_child`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_element_child(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXElementChild {
+    #[doc = "Calls [Fold`::fold_jsx_element_child`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_element_child(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXElementChild::JSXText { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::Jsxtext,
-                ));
-                let _field_0 = <JSXText as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXText as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementChild::JSXText { 0: _field_0 }
             }
             JSXElementChild::JSXExprContainer { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::JsxexprContainer,
-                ));
-                let _field_0 = <JSXExprContainer as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXExprContainer as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementChild::JSXExprContainer { 0: _field_0 }
             }
             JSXElementChild::JSXSpreadChild { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::JsxspreadChild,
-                ));
-                let _field_0 = <JSXSpreadChild as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXSpreadChild as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementChild::JSXSpreadChild { 0: _field_0 }
             }
             JSXElementChild::JSXElement { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::Jsxelement,
-                ));
-                let _field_0 = <Box<JSXElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<JSXElement> as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementChild::JSXElement { 0: _field_0 }
             }
             JSXElementChild::JSXFragment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
-                    self::fields::JSXElementChildField::Jsxfragment,
-                ));
-                let _field_0 = <JSXFragment as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXFragment as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementChild::JSXFragment { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElementName {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_element_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_element_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXElementName {
+    #[doc = "Calls [Fold`::fold_jsx_element_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_element_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXElementName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
-                    self::fields::JSXElementNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementName::Ident { 0: _field_0 }
             }
             JSXElementName::JSXMemberExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
-                    self::fields::JSXElementNameField::JsxmemberExpr,
-                ));
-                let _field_0 = <JSXMemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXMemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementName::JSXMemberExpr { 0: _field_0 }
             }
             JSXElementName::JSXNamespacedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
-                    self::fields::JSXElementNameField::JsxnamespacedName,
-                ));
-                let _field_0 = <JSXNamespacedName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXNamespacedName as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXElementName::JSXNamespacedName { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXEmptyExpr {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_empty_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_empty_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXEmptyExpr {
+    #[doc = "Calls [Fold`::fold_jsx_empty_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_empty_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXEmptyExpr { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXEmptyExpr(
-                        self::fields::JSXEmptyExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 JSXEmptyExpr { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXExpr {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXExpr {
+    #[doc = "Calls [Fold`::fold_jsx_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXExpr::JSXEmptyExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExpr(
-                    self::fields::JSXExprField::JsxemptyExpr,
-                ));
-                let _field_0 = <JSXEmptyExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXEmptyExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXExpr::JSXEmptyExpr { 0: _field_0 }
             }
             JSXExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::JSXExpr(self::fields::JSXExprField::Expr));
-                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXExpr::Expr { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXExprContainer {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_expr_container`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_expr_container(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXExprContainer {
+    #[doc = "Calls [Fold`::fold_jsx_expr_container`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_expr_container(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXExprContainer { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
-                        self::fields::JSXExprContainerField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
-                        self::fields::JSXExprContainerField::Expr,
-                    ));
-                    <JSXExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <JSXExpr as FoldWith<V>>::fold_with(expr, visitor) };
                 JSXExprContainer { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXFragment {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_fragment`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXFragment {
+    #[doc = "Calls [Fold`::fold_jsx_fragment`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_fragment(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXFragment {
                 span,
@@ -129137,46 +103688,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXFragment {
                 children,
                 closing,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let opening = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Opening,
-                    ));
-                    <JSXOpeningFragment as FoldWithAstPath<V>>::fold_with_ast_path(
-                        opening,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let children = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Children(usize::MAX),
-                    ));
-                    <Vec<JSXElementChild> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        children,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let closing = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
-                        self::fields::JSXFragmentField::Closing,
-                    ));
-                    <JSXClosingFragment as FoldWithAstPath<V>>::fold_with_ast_path(
-                        closing,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let opening = { <JSXOpeningFragment as FoldWith<V>>::fold_with(opening, visitor) };
+                let children =
+                    { <Vec<JSXElementChild> as FoldWith<V>>::fold_with(children, visitor) };
+                let closing = { <JSXClosingFragment as FoldWith<V>>::fold_with(closing, visitor) };
                 JSXFragment {
                     span,
                     opening,
@@ -129187,142 +103703,66 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXFragment {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXMemberExpr {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_member_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_member_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXMemberExpr {
+    #[doc = "Calls [Fold`::fold_jsx_member_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_member_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXMemberExpr { span, obj, prop } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
-                        self::fields::JSXMemberExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let obj = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
-                        self::fields::JSXMemberExprField::Obj,
-                    ));
-                    <JSXObject as FoldWithAstPath<V>>::fold_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prop = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
-                        self::fields::JSXMemberExprField::Prop,
-                    ));
-                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let obj = { <JSXObject as FoldWith<V>>::fold_with(obj, visitor) };
+                let prop = { <IdentName as FoldWith<V>>::fold_with(prop, visitor) };
                 JSXMemberExpr { span, obj, prop }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXNamespacedName {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_namespaced_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_namespaced_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXNamespacedName {
+    #[doc = "Calls [Fold`::fold_jsx_namespaced_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_namespaced_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXNamespacedName { span, ns, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
-                        self::fields::JSXNamespacedNameField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ns = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
-                        self::fields::JSXNamespacedNameField::Ns,
-                    ));
-                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ns,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
-                        self::fields::JSXNamespacedNameField::Name,
-                    ));
-                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ns = { <IdentName as FoldWith<V>>::fold_with(ns, visitor) };
+                let name = { <IdentName as FoldWith<V>>::fold_with(name, visitor) };
                 JSXNamespacedName { span, ns, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXObject {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_object`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_object(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXObject {
+    #[doc = "Calls [Fold`::fold_jsx_object`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_object(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXObject::JSXMemberExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
-                    self::fields::JSXObjectField::JsxmemberExpr,
-                ));
-                let _field_0 = <Box<JSXMemberExpr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<JSXMemberExpr> as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXObject::JSXMemberExpr { 0: _field_0 }
             }
             JSXObject::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
-                    self::fields::JSXObjectField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 JSXObject::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXOpeningElement {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_opening_element`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_opening_element(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXOpeningElement {
+    #[doc = "Calls [Fold`::fold_jsx_opening_element`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_opening_element(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXOpeningElement {
                 name,
@@ -129331,41 +103771,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXOpeningElement {
                 self_closing,
                 type_args,
             } => {
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::Name,
-                    ));
-                    <JSXElementName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let attrs = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::Attrs(usize::MAX),
-                    ));
-                    <Vec<JSXAttrOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        attrs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let name = { <JSXElementName as FoldWith<V>>::fold_with(name, visitor) };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let attrs = { <Vec<JSXAttrOrSpread> as FoldWith<V>>::fold_with(attrs, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
-                        self::fields::JSXOpeningElementField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_args, visitor,
+                    )
                 };
                 JSXOpeningElement {
                     name,
@@ -129378,497 +103790,237 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXOpeningElement {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXOpeningFragment {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_opening_fragment`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_opening_fragment(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXOpeningFragment {
+    #[doc = "Calls [Fold`::fold_jsx_opening_fragment`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_opening_fragment(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXOpeningFragment { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningFragment(
-                        self::fields::JSXOpeningFragmentField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 JSXOpeningFragment { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXSpreadChild {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_spread_child`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_spread_child(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXSpreadChild {
+    #[doc = "Calls [Fold`::fold_jsx_spread_child`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_spread_child(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXSpreadChild { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
-                        self::fields::JSXSpreadChildField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
-                        self::fields::JSXSpreadChildField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 JSXSpreadChild { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXText {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_text`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_text(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for JSXText {
+    #[doc = "Calls [Fold`::fold_jsx_text`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_text(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             JSXText { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Raw));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 JSXText { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Key {
-    #[doc = "Calls [FoldAstPath`::fold_key`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_key(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Key {
+    #[doc = "Calls [Fold`::fold_key`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_key(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Key::Private { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Private));
-                let _field_0 = <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PrivateName as FoldWith<V>>::fold_with(_field_0, visitor);
                 Key::Private { 0: _field_0 }
             }
             Key::Public { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Public));
-                let _field_0 = <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PropName as FoldWith<V>>::fold_with(_field_0, visitor);
                 Key::Public { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyValuePatProp {
-    #[doc = "Calls [FoldAstPath`::fold_key_value_pat_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_key_value_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for KeyValuePatProp {
+    #[doc = "Calls [Fold`::fold_key_value_pat_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_key_value_pat_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             KeyValuePatProp { key, value } => {
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
-                        self::fields::KeyValuePatPropField::Key,
-                    ));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
-                        self::fields::KeyValuePatPropField::Value,
-                    ));
-                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Box<Pat> as FoldWith<V>>::fold_with(value, visitor) };
                 KeyValuePatProp { key, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyValueProp {
-    #[doc = "Calls [FoldAstPath`::fold_key_value_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_key_value_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for KeyValueProp {
+    #[doc = "Calls [Fold`::fold_key_value_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_key_value_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             KeyValueProp { key, value } => {
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
-                        self::fields::KeyValuePropField::Key,
-                    ));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
-                        self::fields::KeyValuePropField::Value,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Box<Expr> as FoldWith<V>>::fold_with(value, visitor) };
                 KeyValueProp { key, value }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LabeledStmt {
-    #[doc = "Calls [FoldAstPath`::fold_labeled_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_labeled_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for LabeledStmt {
+    #[doc = "Calls [Fold`::fold_labeled_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_labeled_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             LabeledStmt { span, label, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
-                        self::fields::LabeledStmtField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let label = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
-                        self::fields::LabeledStmtField::Label,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
-                        self::fields::LabeledStmtField::Body,
-                    ));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let label = { <Ident as FoldWith<V>>::fold_with(label, visitor) };
+                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
                 LabeledStmt { span, label, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Lit {
-    #[doc = "Calls [FoldAstPath`::fold_lit`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Lit {
+    #[doc = "Calls [Fold`::fold_lit`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_lit(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Lit::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Str));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 Lit::Str { 0: _field_0 }
             }
             Lit::Bool { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Bool));
-                let _field_0 = <Bool as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Bool as FoldWith<V>>::fold_with(_field_0, visitor);
                 Lit::Bool { 0: _field_0 }
             }
             Lit::Null { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Null));
-                let _field_0 = <Null as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Null as FoldWith<V>>::fold_with(_field_0, visitor);
                 Lit::Null { 0: _field_0 }
             }
             Lit::Num { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Num));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 Lit::Num { 0: _field_0 }
             }
             Lit::BigInt { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::BigInt));
-                let _field_0 = <BigInt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BigInt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Lit::BigInt { 0: _field_0 }
             }
             Lit::Regex { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Regex));
-                let _field_0 = <Regex as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Regex as FoldWith<V>>::fold_with(_field_0, visitor);
                 Lit::Regex { 0: _field_0 }
             }
             Lit::JSXText { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Jsxtext));
-                let _field_0 = <JSXText as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <JSXText as FoldWith<V>>::fold_with(_field_0, visitor);
                 Lit::JSXText { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MemberExpr {
-    #[doc = "Calls [FoldAstPath`::fold_member_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_member_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MemberExpr {
+    #[doc = "Calls [Fold`::fold_member_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_member_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MemberExpr { span, obj, prop } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
-                        self::fields::MemberExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let obj = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
-                        self::fields::MemberExprField::Obj,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prop = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
-                        self::fields::MemberExprField::Prop,
-                    ));
-                    <MemberProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let obj = { <Box<Expr> as FoldWith<V>>::fold_with(obj, visitor) };
+                let prop = { <MemberProp as FoldWith<V>>::fold_with(prop, visitor) };
                 MemberExpr { span, obj, prop }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MemberProp {
-    #[doc = "Calls [FoldAstPath`::fold_member_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_member_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MemberProp {
+    #[doc = "Calls [Fold`::fold_member_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_member_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MemberProp::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
-                    self::fields::MemberPropField::Ident,
-                ));
-                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
                 MemberProp::Ident { 0: _field_0 }
             }
             MemberProp::PrivateName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
-                    self::fields::MemberPropField::PrivateName,
-                ));
-                let _field_0 = <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <PrivateName as FoldWith<V>>::fold_with(_field_0, visitor);
                 MemberProp::PrivateName { 0: _field_0 }
             }
             MemberProp::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
-                    self::fields::MemberPropField::Computed,
-                ));
-                let _field_0 = <ComputedPropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ComputedPropName as FoldWith<V>>::fold_with(_field_0, visitor);
                 MemberProp::Computed { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MetaPropExpr {
-    #[doc = "Calls [FoldAstPath`::fold_meta_prop_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_meta_prop_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MetaPropExpr {
+    #[doc = "Calls [Fold`::fold_meta_prop_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_meta_prop_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MetaPropExpr { span, kind } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
-                        self::fields::MetaPropExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let kind = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
-                        self::fields::MetaPropExprField::Kind,
-                    ));
-                    <MetaPropKind as FoldWithAstPath<V>>::fold_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let kind = { <MetaPropKind as FoldWith<V>>::fold_with(kind, visitor) };
                 MetaPropExpr { span, kind }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MetaPropKind {
-    #[doc = "Calls [FoldAstPath`::fold_meta_prop_kind`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_meta_prop_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MetaPropKind {
+    #[doc = "Calls [Fold`::fold_meta_prop_kind`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_meta_prop_kind(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MetaPropKind::NewTarget => MetaPropKind::NewTarget,
             MetaPropKind::ImportMeta => MetaPropKind::ImportMeta,
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MethodKind {
-    #[doc = "Calls [FoldAstPath`::fold_method_kind`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_method_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MethodKind {
+    #[doc = "Calls [Fold`::fold_method_kind`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_method_kind(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MethodKind::Method => MethodKind::Method,
             MethodKind::Getter => MethodKind::Getter,
@@ -129876,85 +104028,39 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MethodKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MethodProp {
-    #[doc = "Calls [FoldAstPath`::fold_method_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_method_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for MethodProp {
+    #[doc = "Calls [Fold`::fold_method_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_method_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             MethodProp { key, function } => {
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
-                        self::fields::MethodPropField::Key,
-                    ));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let function = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
-                        self::fields::MethodPropField::Function,
-                    ));
-                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
                 MethodProp { key, function }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Module {
-    #[doc = "Calls [FoldAstPath`::fold_module`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_module(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Module {
+    #[doc = "Calls [Fold`::fold_module`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_module(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Module {
                 span,
                 body,
                 shebang,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Module(
-                        self::fields::ModuleField::Body(usize::MAX),
-                    ));
-                    <Vec<ModuleItem> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let shebang = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Shebang));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        shebang,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let body = { <Vec<ModuleItem> as FoldWith<V>>::fold_with(body, visitor) };
+                let shebang =
+                    { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(shebang, visitor) };
                 Module {
                     span,
                     body,
@@ -129964,197 +104070,99 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Module {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ModuleDecl {
-    #[doc = "Calls [FoldAstPath`::fold_module_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_module_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ModuleDecl {
+    #[doc = "Calls [Fold`::fold_module_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_module_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ModuleDecl::Import { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::Import,
-                ));
-                let _field_0 = <ImportDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ImportDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::Import { 0: _field_0 }
             }
             ModuleDecl::ExportDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportDecl,
-                ));
-                let _field_0 = <ExportDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ExportDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::ExportDecl { 0: _field_0 }
             }
             ModuleDecl::ExportNamed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportNamed,
-                ));
-                let _field_0 = <NamedExport as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <NamedExport as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::ExportNamed { 0: _field_0 }
             }
             ModuleDecl::ExportDefaultDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportDefaultDecl,
-                ));
-                let _field_0 = <ExportDefaultDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ExportDefaultDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::ExportDefaultDecl { 0: _field_0 }
             }
             ModuleDecl::ExportDefaultExpr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportDefaultExpr,
-                ));
-                let _field_0 = <ExportDefaultExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ExportDefaultExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::ExportDefaultExpr { 0: _field_0 }
             }
             ModuleDecl::ExportAll { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::ExportAll,
-                ));
-                let _field_0 = <ExportAll as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ExportAll as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::ExportAll { 0: _field_0 }
             }
             ModuleDecl::TsImportEquals { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::TsImportEquals,
-                ));
-                let _field_0 = <Box<TsImportEqualsDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <Box<TsImportEqualsDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::TsImportEquals { 0: _field_0 }
             }
             ModuleDecl::TsExportAssignment { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::TsExportAssignment,
-                ));
-                let _field_0 = <TsExportAssignment as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsExportAssignment as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::TsExportAssignment { 0: _field_0 }
             }
             ModuleDecl::TsNamespaceExport { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
-                    self::fields::ModuleDeclField::TsNamespaceExport,
-                ));
-                let _field_0 = <TsNamespaceExportDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsNamespaceExportDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleDecl::TsNamespaceExport { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ModuleExportName {
-    #[doc = "Calls [FoldAstPath`::fold_module_export_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_module_export_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ModuleExportName {
+    #[doc = "Calls [Fold`::fold_module_export_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_module_export_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ModuleExportName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
-                    self::fields::ModuleExportNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleExportName::Ident { 0: _field_0 }
             }
             ModuleExportName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
-                    self::fields::ModuleExportNameField::Str,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleExportName::Str { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ModuleItem {
-    #[doc = "Calls [FoldAstPath`::fold_module_item`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_module_item(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ModuleItem {
+    #[doc = "Calls [Fold`::fold_module_item`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_module_item(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ModuleItem::ModuleDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
-                    self::fields::ModuleItemField::ModuleDecl,
-                ));
-                let _field_0 = <ModuleDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ModuleDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleItem::ModuleDecl { 0: _field_0 }
             }
             ModuleItem::Stmt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
-                    self::fields::ModuleItemField::Stmt,
-                ));
-                let _field_0 = <Stmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Stmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 ModuleItem::Stmt { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamedExport {
-    #[doc = "Calls [FoldAstPath`::fold_named_export`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_named_export(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NamedExport {
+    #[doc = "Calls [Fold`::fold_named_export`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_named_export(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             NamedExport {
                 span,
@@ -130163,46 +104171,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamedExport {
                 type_only,
                 with,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let specifiers = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::Specifiers(usize::MAX),
-                    ));
-                    <Vec<ExportSpecifier> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        specifiers,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let src = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::Src,
-                    ));
-                    <Option<Box<Str>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        src,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let with = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
-                        self::fields::NamedExportField::With,
-                    ));
-                    <Option<Box<ObjectLit>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        with,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let specifiers =
+                    { <Vec<ExportSpecifier> as FoldWith<V>>::fold_with(specifiers, visitor) };
+                let src = { <Option<Box<Str>> as FoldWith<V>>::fold_with(src, visitor) };
+                let with = { <Option<Box<ObjectLit>> as FoldWith<V>>::fold_with(with, visitor) };
                 NamedExport {
                     span,
                     specifiers,
@@ -130214,15 +104187,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamedExport {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NewExpr {
-    #[doc = "Calls [FoldAstPath`::fold_new_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_new_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for NewExpr {
+    #[doc = "Calls [Fold`::fold_new_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_new_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             NewExpr {
                 span,
@@ -130231,47 +104202,14 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NewExpr {
                 args,
                 type_args,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let callee = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Callee));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NewExpr(
-                        self::fields::NewExprField::Args(usize::MAX),
-                    ));
-                    <Option<Vec<ExprOrSpread>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let callee = { <Box<Expr> as FoldWith<V>>::fold_with(callee, visitor) };
+                let args = { <Option<Vec<ExprOrSpread>> as FoldWith<V>>::fold_with(args, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::TypeArgs));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_args, visitor,
+                    )
                 };
                 NewExpr {
                     span,
@@ -130284,109 +104222,60 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NewExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Null {
-    #[doc = "Calls [FoldAstPath`::fold_null`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_null(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Null {
+    #[doc = "Calls [Fold`::fold_null`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_null(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Null { span } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Null(self::fields::NullField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 Null { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Number {
-    #[doc = "Calls [FoldAstPath`::fold_number`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_number(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Number {
+    #[doc = "Calls [Fold`::fold_number`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_number(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Number { span, value, raw } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 Number { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectLit {
-    #[doc = "Calls [FoldAstPath`::fold_object_lit`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_object_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ObjectLit {
+    #[doc = "Calls [Fold`::fold_object_lit`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_object_lit(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ObjectLit { span, props } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ObjectLit(self::fields::ObjectLitField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let props = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectLit(
-                        self::fields::ObjectLitField::Props(usize::MAX),
-                    ));
-                    <Vec<PropOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        props,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let props = { <Vec<PropOrSpread> as FoldWith<V>>::fold_with(props, visitor) };
                 ObjectLit { span, props }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectPat {
-    #[doc = "Calls [FoldAstPath`::fold_object_pat`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_object_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ObjectPat {
+    #[doc = "Calls [Fold`::fold_object_pat`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_object_pat(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ObjectPat {
                 span,
@@ -130394,35 +104283,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectPat {
                 optional,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ObjectPat(self::fields::ObjectPatField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let props = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
-                        self::fields::ObjectPatField::Props(usize::MAX),
-                    ));
-                    <Vec<ObjectPatProp> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        props,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
-                        self::fields::ObjectPatField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let props = { <Vec<ObjectPatProp> as FoldWith<V>>::fold_with(props, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 ObjectPat {
                     span,
                     props,
@@ -130433,61 +104297,36 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectPat {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectPatProp {
-    #[doc = "Calls [FoldAstPath`::fold_object_pat_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_object_pat_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ObjectPatProp {
+    #[doc = "Calls [Fold`::fold_object_pat_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_object_pat_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ObjectPatProp::KeyValue { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
-                    self::fields::ObjectPatPropField::KeyValue,
-                ));
-                let _field_0 = <KeyValuePatProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <KeyValuePatProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 ObjectPatProp::KeyValue { 0: _field_0 }
             }
             ObjectPatProp::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
-                    self::fields::ObjectPatPropField::Assign,
-                ));
-                let _field_0 = <AssignPatProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AssignPatProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 ObjectPatProp::Assign { 0: _field_0 }
             }
             ObjectPatProp::Rest { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
-                    self::fields::ObjectPatPropField::Rest,
-                ));
-                let _field_0 = <RestPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <RestPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 ObjectPatProp::Rest { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptCall {
-    #[doc = "Calls [FoldAstPath`::fold_opt_call`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_call(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for OptCall {
+    #[doc = "Calls [Fold`::fold_opt_call`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_call(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             OptCall {
                 span,
@@ -130496,47 +104335,14 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptCall {
                 args,
                 type_args,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let callee = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Callee));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        callee,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptCall(
-                        self::fields::OptCallField::Args(usize::MAX),
-                    ));
-                    <Vec<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let callee = { <Box<Expr> as FoldWith<V>>::fold_with(callee, visitor) };
+                let args = { <Vec<ExprOrSpread> as FoldWith<V>>::fold_with(args, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::TypeArgs));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_args, visitor,
+                    )
                 };
                 OptCall {
                     span,
@@ -130549,76 +104355,40 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptCall {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptChainBase {
-    #[doc = "Calls [FoldAstPath`::fold_opt_chain_base`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_chain_base(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for OptChainBase {
+    #[doc = "Calls [Fold`::fold_opt_chain_base`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_chain_base(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             OptChainBase::Member { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
-                    self::fields::OptChainBaseField::Member,
-                ));
-                let _field_0 = <MemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 OptChainBase::Member { 0: _field_0 }
             }
             OptChainBase::Call { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
-                    self::fields::OptChainBaseField::Call,
-                ));
-                let _field_0 = <OptCall as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <OptCall as FoldWith<V>>::fold_with(_field_0, visitor);
                 OptChainBase::Call { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptChainExpr {
-    #[doc = "Calls [FoldAstPath`::fold_opt_chain_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_chain_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for OptChainExpr {
+    #[doc = "Calls [Fold`::fold_opt_chain_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_chain_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             OptChainExpr {
                 span,
                 optional,
                 base,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
-                        self::fields::OptChainExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let base = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
-                        self::fields::OptChainExprField::Base,
-                    ));
-                    <Box<OptChainBase> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        base,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let base = { <Box<OptChainBase> as FoldWith<V>>::fold_with(base, visitor) };
                 OptChainExpr {
                     span,
                     optional,
@@ -130628,45 +104398,23 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptChainExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Param {
-    #[doc = "Calls [FoldAstPath`::fold_param`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_param(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Param {
+    #[doc = "Calls [Fold`::fold_param`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_param(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Param {
                 span,
                 decorators,
                 pat,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decorators = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Param(
-                        self::fields::ParamField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let pat = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Pat));
-                    <Pat as FoldWithAstPath<V>>::fold_with_ast_path(pat, visitor, &mut *__ast_path)
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let decorators =
+                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
+                let pat = { <Pat as FoldWith<V>>::fold_with(pat, visitor) };
                 Param {
                     span,
                     decorators,
@@ -130676,167 +104424,87 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Param {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ParamOrTsParamProp {
-    #[doc = "Calls [FoldAstPath`::fold_param_or_ts_param_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_param_or_ts_param_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ParamOrTsParamProp {
+    #[doc = "Calls [Fold`::fold_param_or_ts_param_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_param_or_ts_param_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ParamOrTsParamProp::TsParamProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
-                    self::fields::ParamOrTsParamPropField::TsParamProp,
-                ));
-                let _field_0 = <TsParamProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsParamProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 ParamOrTsParamProp::TsParamProp { 0: _field_0 }
             }
             ParamOrTsParamProp::Param { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
-                    self::fields::ParamOrTsParamPropField::Param,
-                ));
-                let _field_0 = <Param as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Param as FoldWith<V>>::fold_with(_field_0, visitor);
                 ParamOrTsParamProp::Param { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ParenExpr {
-    #[doc = "Calls [FoldAstPath`::fold_paren_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_paren_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ParenExpr {
+    #[doc = "Calls [Fold`::fold_paren_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_paren_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ParenExpr { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Expr));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 ParenExpr { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Pat {
-    #[doc = "Calls [FoldAstPath`::fold_pat`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Pat {
+    #[doc = "Calls [Fold`::fold_pat`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pat(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Pat::Ident { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Ident));
-                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 Pat::Ident { 0: _field_0 }
             }
             Pat::Array { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Array));
-                let _field_0 = <ArrayPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ArrayPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 Pat::Array { 0: _field_0 }
             }
             Pat::Rest { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Rest));
-                let _field_0 = <RestPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <RestPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 Pat::Rest { 0: _field_0 }
             }
             Pat::Object { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Object));
-                let _field_0 = <ObjectPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ObjectPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 Pat::Object { 0: _field_0 }
             }
             Pat::Assign { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Assign));
-                let _field_0 = <AssignPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AssignPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 Pat::Assign { 0: _field_0 }
             }
             Pat::Invalid { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Invalid));
-                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
                 Pat::Invalid { 0: _field_0 }
             }
             Pat::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Expr));
-                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Pat::Expr { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateMethod {
-    #[doc = "Calls [FoldAstPath`::fold_private_method`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_private_method(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PrivateMethod {
+    #[doc = "Calls [Fold`::fold_private_method`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_private_method(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PrivateMethod {
                 span,
@@ -130849,56 +104517,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateMethod {
                 is_optional,
                 is_override,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Key,
-                    ));
-                    <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let function = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Function,
-                    ));
-                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        function,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let kind = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Kind,
-                    ));
-                    <MethodKind as FoldWithAstPath<V>>::fold_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let accessibility = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
-                        self::fields::PrivateMethodField::Accessibility,
-                    ));
-                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <PrivateName as FoldWith<V>>::fold_with(key, visitor) };
+                let function = { <Box<Function> as FoldWith<V>>::fold_with(function, visitor) };
+                let kind = { <MethodKind as FoldWith<V>>::fold_with(kind, visitor) };
+                let accessibility =
+                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
                 PrivateMethod {
                     span,
                     key,
@@ -130914,51 +104538,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateMethod {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateName {
-    #[doc = "Calls [FoldAstPath`::fold_private_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_private_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PrivateName {
+    #[doc = "Calls [Fold`::fold_private_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_private_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PrivateName { span, name } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
-                        self::fields::PrivateNameField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
-                        self::fields::PrivateNameField::Name,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <swc_atoms::Atom as FoldWith<V>>::fold_with(name, visitor) };
                 PrivateName { span, name }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateProp {
-    #[doc = "Calls [FoldAstPath`::fold_private_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_private_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PrivateProp {
+    #[doc = "Calls [Fold`::fold_private_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_private_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PrivateProp {
                 span,
@@ -130974,76 +104576,16 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateProp {
                 readonly,
                 definite,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Ctxt,
-                    ));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Key,
-                    ));
-                    <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Value,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decorators = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let accessibility = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
-                        self::fields::PrivatePropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let key = { <PrivateName as FoldWith<V>>::fold_with(key, visitor) };
+                let value = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(value, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
+                let decorators =
+                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
+                let accessibility =
+                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
                 PrivateProp {
                     span,
                     ctxt,
@@ -131062,263 +104604,134 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateProp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Program {
-    #[doc = "Calls [FoldAstPath`::fold_program`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_program(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Program {
+    #[doc = "Calls [Fold`::fold_program`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_program(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Program::Module { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Module));
-                let _field_0 = <Module as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Module as FoldWith<V>>::fold_with(_field_0, visitor);
                 Program::Module { 0: _field_0 }
             }
             Program::Script { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Script));
-                let _field_0 = <Script as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Script as FoldWith<V>>::fold_with(_field_0, visitor);
                 Program::Script { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Prop {
-    #[doc = "Calls [FoldAstPath`::fold_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Prop {
+    #[doc = "Calls [Fold`::fold_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Prop::Shorthand { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Shorthand));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 Prop::Shorthand { 0: _field_0 }
             }
             Prop::KeyValue { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::KeyValue));
-                let _field_0 = <KeyValueProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <KeyValueProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 Prop::KeyValue { 0: _field_0 }
             }
             Prop::Assign { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Assign));
-                let _field_0 = <AssignProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AssignProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 Prop::Assign { 0: _field_0 }
             }
             Prop::Getter { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Getter));
-                let _field_0 = <GetterProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <GetterProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 Prop::Getter { 0: _field_0 }
             }
             Prop::Setter { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Setter));
-                let _field_0 = <SetterProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SetterProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 Prop::Setter { 0: _field_0 }
             }
             Prop::Method { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Method));
-                let _field_0 = <MethodProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MethodProp as FoldWith<V>>::fold_with(_field_0, visitor);
                 Prop::Method { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PropName {
-    #[doc = "Calls [FoldAstPath`::fold_prop_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_prop_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PropName {
+    #[doc = "Calls [Fold`::fold_prop_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_prop_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PropName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Ident));
-                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
                 PropName::Ident { 0: _field_0 }
             }
             PropName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Str));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 PropName::Str { 0: _field_0 }
             }
             PropName::Num { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Num));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 PropName::Num { 0: _field_0 }
             }
             PropName::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropName(
-                    self::fields::PropNameField::Computed,
-                ));
-                let _field_0 = <ComputedPropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ComputedPropName as FoldWith<V>>::fold_with(_field_0, visitor);
                 PropName::Computed { 0: _field_0 }
             }
             PropName::BigInt { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::BigInt));
-                let _field_0 = <BigInt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BigInt as FoldWith<V>>::fold_with(_field_0, visitor);
                 PropName::BigInt { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PropOrSpread {
-    #[doc = "Calls [FoldAstPath`::fold_prop_or_spread`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_prop_or_spread(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for PropOrSpread {
+    #[doc = "Calls [Fold`::fold_prop_or_spread`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_prop_or_spread(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             PropOrSpread::Spread { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
-                    self::fields::PropOrSpreadField::Spread,
-                ));
-                let _field_0 = <SpreadElement as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SpreadElement as FoldWith<V>>::fold_with(_field_0, visitor);
                 PropOrSpread::Spread { 0: _field_0 }
             }
             PropOrSpread::Prop { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
-                    self::fields::PropOrSpreadField::Prop,
-                ));
-                let _field_0 = <Box<Prop> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<Prop> as FoldWith<V>>::fold_with(_field_0, visitor);
                 PropOrSpread::Prop { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Regex {
-    #[doc = "Calls [FoldAstPath`::fold_regex`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_regex(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Regex {
+    #[doc = "Calls [Fold`::fold_regex`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_regex(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Regex { span, exp, flags } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let exp = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Exp));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        exp,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let flags = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Regex(self::fields::RegexField::Flags));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        flags,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let exp = { <swc_atoms::Atom as FoldWith<V>>::fold_with(exp, visitor) };
+                let flags = { <swc_atoms::Atom as FoldWith<V>>::fold_with(flags, visitor) };
                 Regex { span, exp, flags }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RestPat {
-    #[doc = "Calls [FoldAstPath`::fold_rest_pat`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_rest_pat(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for RestPat {
+    #[doc = "Calls [Fold`::fold_rest_pat`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_rest_pat(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             RestPat {
                 span,
@@ -131326,43 +104739,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RestPat {
                 arg,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let dot3_token = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RestPat(
-                        self::fields::RestPatField::Dot3Token,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        dot3_token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Arg));
-                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::TypeAnn));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let dot3_token =
+                    { <swc_common::Span as FoldWith<V>>::fold_with(dot3_token, visitor) };
+                let arg = { <Box<Pat> as FoldWith<V>>::fold_with(arg, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 RestPat {
                     span,
                     dot3_token,
@@ -131373,85 +104755,39 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RestPat {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ReturnStmt {
-    #[doc = "Calls [FoldAstPath`::fold_return_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_return_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ReturnStmt {
+    #[doc = "Calls [Fold`::fold_return_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_return_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ReturnStmt { span, arg } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
-                        self::fields::ReturnStmtField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
-                        self::fields::ReturnStmtField::Arg,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let arg = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(arg, visitor) };
                 ReturnStmt { span, arg }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Script {
-    #[doc = "Calls [FoldAstPath`::fold_script`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_script(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Script {
+    #[doc = "Calls [Fold`::fold_script`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_script(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Script {
                 span,
                 body,
                 shebang,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Script(
-                        self::fields::ScriptField::Body(usize::MAX),
-                    ));
-                    <Vec<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let shebang = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Shebang));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        shebang,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let body = { <Vec<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
+                let shebang =
+                    { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(shebang, visitor) };
                 Script {
                     span,
                     body,
@@ -131461,50 +104797,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Script {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SeqExpr {
-    #[doc = "Calls [FoldAstPath`::fold_seq_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_seq_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SeqExpr {
+    #[doc = "Calls [Fold`::fold_seq_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_seq_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SeqExpr { span, exprs } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::SeqExpr(self::fields::SeqExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let exprs = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SeqExpr(
-                        self::fields::SeqExprField::Exprs(usize::MAX),
-                    ));
-                    <Vec<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        exprs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let exprs = { <Vec<Box<Expr>> as FoldWith<V>>::fold_with(exprs, visitor) };
                 SeqExpr { span, exprs }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SetterProp {
-    #[doc = "Calls [FoldAstPath`::fold_setter_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_setter_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SetterProp {
+    #[doc = "Calls [Fold`::fold_setter_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_setter_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SetterProp {
                 span,
@@ -131513,56 +104828,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SetterProp {
                 param,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Key,
-                    ));
-                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let this_param = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::ThisParam,
-                    ));
-                    <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        this_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let param = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Param,
-                    ));
-                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
-                        self::fields::SetterPropField::Body,
-                    ));
-                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <PropName as FoldWith<V>>::fold_with(key, visitor) };
+                let this_param = { <Option<Pat> as FoldWith<V>>::fold_with(this_param, visitor) };
+                let param = { <Box<Pat> as FoldWith<V>>::fold_with(param, visitor) };
+                let body = { <Option<BlockStmt> as FoldWith<V>>::fold_with(body, visitor) };
                 SetterProp {
                     span,
                     key,
@@ -131574,655 +104844,282 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SetterProp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SimpleAssignTarget {
-    #[doc = "Calls [FoldAstPath`::fold_simple_assign_target`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_simple_assign_target(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SimpleAssignTarget {
+    #[doc = "Calls [Fold`::fold_simple_assign_target`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_simple_assign_target(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SimpleAssignTarget::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Ident,
-                ));
-                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::Ident { 0: _field_0 }
             }
             SimpleAssignTarget::Member { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Member,
-                ));
-                let _field_0 = <MemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <MemberExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::Member { 0: _field_0 }
             }
             SimpleAssignTarget::SuperProp { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::SuperProp,
-                ));
-                let _field_0 = <SuperPropExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SuperPropExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::SuperProp { 0: _field_0 }
             }
             SimpleAssignTarget::Paren { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Paren,
-                ));
-                let _field_0 = <ParenExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ParenExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::Paren { 0: _field_0 }
             }
             SimpleAssignTarget::OptChain { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::OptChain,
-                ));
-                let _field_0 = <OptChainExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <OptChainExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::OptChain { 0: _field_0 }
             }
             SimpleAssignTarget::TsAs { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsAs,
-                ));
-                let _field_0 = <TsAsExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsAsExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::TsAs { 0: _field_0 }
             }
             SimpleAssignTarget::TsSatisfies { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsSatisfies,
-                ));
-                let _field_0 = <TsSatisfiesExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsSatisfiesExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::TsSatisfies { 0: _field_0 }
             }
             SimpleAssignTarget::TsNonNull { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsNonNull,
-                ));
-                let _field_0 = <TsNonNullExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsNonNullExpr as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::TsNonNull { 0: _field_0 }
             }
             SimpleAssignTarget::TsTypeAssertion { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsTypeAssertion,
-                ));
-                let _field_0 = <TsTypeAssertion as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTypeAssertion as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::TsTypeAssertion { 0: _field_0 }
             }
             SimpleAssignTarget::TsInstantiation { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::TsInstantiation,
-                ));
-                let _field_0 = <TsInstantiation as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsInstantiation as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::TsInstantiation { 0: _field_0 }
             }
             SimpleAssignTarget::Invalid { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
-                    self::fields::SimpleAssignTargetField::Invalid,
-                ));
-                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Invalid as FoldWith<V>>::fold_with(_field_0, visitor);
                 SimpleAssignTarget::Invalid { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SpreadElement {
-    #[doc = "Calls [FoldAstPath`::fold_spread_element`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_spread_element(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SpreadElement {
+    #[doc = "Calls [Fold`::fold_spread_element`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_spread_element(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SpreadElement { dot3_token, expr } => {
-                let dot3_token = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
-                        self::fields::SpreadElementField::Dot3Token,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        dot3_token,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
-                        self::fields::SpreadElementField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let dot3_token =
+                    { <swc_common::Span as FoldWith<V>>::fold_with(dot3_token, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 SpreadElement { dot3_token, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for StaticBlock {
-    #[doc = "Calls [FoldAstPath`::fold_static_block`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_static_block(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            StaticBlock { span, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
-                        self::fields::StaticBlockField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
-                        self::fields::StaticBlockField::Body,
-                    ));
-                    <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+impl<V: ?Sized + Fold> FoldWith<V> for StaticBlock {
+    #[doc = "Calls [Fold`::fold_static_block`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_static_block(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            StaticBlock { span, body } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let body = { <BlockStmt as FoldWith<V>>::fold_with(body, visitor) };
                 StaticBlock { span, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Stmt {
-    #[doc = "Calls [FoldAstPath`::fold_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Stmt {
+    #[doc = "Calls [Fold`::fold_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Stmt::Block { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Block));
-                let _field_0 = <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BlockStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Block { 0: _field_0 }
             }
             Stmt::Empty { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Empty));
-                let _field_0 = <EmptyStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <EmptyStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Empty { 0: _field_0 }
             }
             Stmt::Debugger { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Debugger));
-                let _field_0 = <DebuggerStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DebuggerStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Debugger { 0: _field_0 }
             }
             Stmt::With { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::With));
-                let _field_0 = <WithStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <WithStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::With { 0: _field_0 }
             }
             Stmt::Return { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Return));
-                let _field_0 = <ReturnStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ReturnStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Return { 0: _field_0 }
             }
             Stmt::Labeled { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Labeled));
-                let _field_0 = <LabeledStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <LabeledStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Labeled { 0: _field_0 }
             }
             Stmt::Break { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Break));
-                let _field_0 = <BreakStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BreakStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Break { 0: _field_0 }
             }
             Stmt::Continue { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Continue));
-                let _field_0 = <ContinueStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ContinueStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Continue { 0: _field_0 }
             }
             Stmt::If { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::If));
-                let _field_0 = <IfStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <IfStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::If { 0: _field_0 }
             }
             Stmt::Switch { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Switch));
-                let _field_0 = <SwitchStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <SwitchStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Switch { 0: _field_0 }
             }
             Stmt::Throw { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Throw));
-                let _field_0 = <ThrowStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ThrowStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Throw { 0: _field_0 }
             }
             Stmt::Try { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Try));
-                let _field_0 = <Box<TryStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TryStmt> as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Try { 0: _field_0 }
             }
             Stmt::While { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::While));
-                let _field_0 = <WhileStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <WhileStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::While { 0: _field_0 }
             }
             Stmt::DoWhile { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::DoWhile));
-                let _field_0 = <DoWhileStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <DoWhileStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::DoWhile { 0: _field_0 }
             }
             Stmt::For { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::For));
-                let _field_0 = <ForStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ForStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::For { 0: _field_0 }
             }
             Stmt::ForIn { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForIn));
-                let _field_0 = <ForInStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ForInStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::ForIn { 0: _field_0 }
             }
             Stmt::ForOf { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForOf));
-                let _field_0 = <ForOfStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ForOfStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::ForOf { 0: _field_0 }
             }
             Stmt::Decl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Decl));
-                let _field_0 = <Decl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Decl as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Decl { 0: _field_0 }
             }
             Stmt::Expr { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Expr));
-                let _field_0 = <ExprStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ExprStmt as FoldWith<V>>::fold_with(_field_0, visitor);
                 Stmt::Expr { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Str {
-    #[doc = "Calls [FoldAstPath`::fold_str`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_str(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Str {
+    #[doc = "Calls [Fold`::fold_str`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_str(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Str { span, value, raw } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let value = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        value,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let value = { <swc_atoms::Atom as FoldWith<V>>::fold_with(value, visitor) };
+                let raw = { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(raw, visitor) };
                 Str { span, value, raw }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Super {
-    #[doc = "Calls [FoldAstPath`::fold_super`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_super(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Super {
+    #[doc = "Calls [Fold`::fold_super`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_super(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Super { span } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Super(self::fields::SuperField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 Super { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SuperProp {
-    #[doc = "Calls [FoldAstPath`::fold_super_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_super_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SuperProp {
+    #[doc = "Calls [Fold`::fold_super_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_super_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SuperProp::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
-                    self::fields::SuperPropField::Ident,
-                ));
-                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <IdentName as FoldWith<V>>::fold_with(_field_0, visitor);
                 SuperProp::Ident { 0: _field_0 }
             }
             SuperProp::Computed { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
-                    self::fields::SuperPropField::Computed,
-                ));
-                let _field_0 = <ComputedPropName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ComputedPropName as FoldWith<V>>::fold_with(_field_0, visitor);
                 SuperProp::Computed { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SuperPropExpr {
-    #[doc = "Calls [FoldAstPath`::fold_super_prop_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_super_prop_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SuperPropExpr {
+    #[doc = "Calls [Fold`::fold_super_prop_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_super_prop_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SuperPropExpr { span, obj, prop } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
-                        self::fields::SuperPropExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let obj = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
-                        self::fields::SuperPropExprField::Obj,
-                    ));
-                    <Super as FoldWithAstPath<V>>::fold_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let prop = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
-                        self::fields::SuperPropExprField::Prop,
-                    ));
-                    <SuperProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                        prop,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let obj = { <Super as FoldWith<V>>::fold_with(obj, visitor) };
+                let prop = { <SuperProp as FoldWith<V>>::fold_with(prop, visitor) };
                 SuperPropExpr { span, obj, prop }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SwitchCase {
-    #[doc = "Calls [FoldAstPath`::fold_switch_case`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_switch_case(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SwitchCase {
+    #[doc = "Calls [Fold`::fold_switch_case`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_switch_case(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SwitchCase { span, test, cons } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
-                        self::fields::SwitchCaseField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let test = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
-                        self::fields::SwitchCaseField::Test,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let cons = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
-                        self::fields::SwitchCaseField::Cons(usize::MAX),
-                    ));
-                    <Vec<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        cons,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let test = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(test, visitor) };
+                let cons = { <Vec<Stmt> as FoldWith<V>>::fold_with(cons, visitor) };
                 SwitchCase { span, test, cons }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SwitchStmt {
-    #[doc = "Calls [FoldAstPath`::fold_switch_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_switch_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for SwitchStmt {
+    #[doc = "Calls [Fold`::fold_switch_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_switch_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             SwitchStmt {
                 span,
                 discriminant,
                 cases,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
-                        self::fields::SwitchStmtField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let discriminant = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
-                        self::fields::SwitchStmtField::Discriminant,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        discriminant,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let cases = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
-                        self::fields::SwitchStmtField::Cases(usize::MAX),
-                    ));
-                    <Vec<SwitchCase> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        cases,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let discriminant = { <Box<Expr> as FoldWith<V>>::fold_with(discriminant, visitor) };
+                let cases = { <Vec<SwitchCase> as FoldWith<V>>::fold_with(cases, visitor) };
                 SwitchStmt {
                     span,
                     discriminant,
@@ -132232,15 +105129,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SwitchStmt {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TaggedTpl {
-    #[doc = "Calls [FoldAstPath`::fold_tagged_tpl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_tagged_tpl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TaggedTpl {
+    #[doc = "Calls [Fold`::fold_tagged_tpl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_tagged_tpl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TaggedTpl {
                 span,
@@ -132249,48 +105144,16 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TaggedTpl {
                 type_params,
                 tpl,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let tag = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tag));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        tag,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let tag = { <Box<Expr> as FoldWith<V>>::fold_with(tag, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TaggedTpl(
-                        self::fields::TaggedTplField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_params , visitor , & mut * __ast_path)
-                };
-                let tpl = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tpl));
-                    <Box<Tpl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        tpl,
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
+                let tpl = { <Box<Tpl> as FoldWith<V>>::fold_with(tpl, visitor) };
                 TaggedTpl {
                     span,
                     ctxt,
@@ -132302,109 +105165,53 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TaggedTpl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ThisExpr {
-    #[doc = "Calls [FoldAstPath`::fold_this_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_this_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ThisExpr {
+    #[doc = "Calls [Fold`::fold_this_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_this_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ThisExpr { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ThisExpr(self::fields::ThisExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 ThisExpr { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ThrowStmt {
-    #[doc = "Calls [FoldAstPath`::fold_throw_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_throw_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for ThrowStmt {
+    #[doc = "Calls [Fold`::fold_throw_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_throw_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             ThrowStmt { span, arg } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Arg));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
                 ThrowStmt { span, arg }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Tpl {
-    #[doc = "Calls [FoldAstPath`::fold_tpl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_tpl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for Tpl {
+    #[doc = "Calls [Fold`::fold_tpl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_tpl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             Tpl {
                 span,
                 exprs,
                 quasis,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::Tpl(self::fields::TplField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let exprs = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
-                        self::fields::TplField::Exprs(usize::MAX),
-                    ));
-                    <Vec<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        exprs,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let quasis = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
-                        self::fields::TplField::Quasis(usize::MAX),
-                    ));
-                    <Vec<TplElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        quasis,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let exprs = { <Vec<Box<Expr>> as FoldWith<V>>::fold_with(exprs, visitor) };
+                let quasis = { <Vec<TplElement> as FoldWith<V>>::fold_with(quasis, visitor) };
                 Tpl {
                     span,
                     exprs,
@@ -132414,15 +105221,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Tpl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TplElement {
-    #[doc = "Calls [FoldAstPath`::fold_tpl_element`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_tpl_element(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TplElement {
+    #[doc = "Calls [Fold`::fold_tpl_element`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_tpl_element(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TplElement {
                 span,
@@ -132430,36 +105235,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TplElement {
                 cooked,
                 raw,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
-                        self::fields::TplElementField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let cooked = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
-                        self::fields::TplElementField::Cooked,
-                    ));
-                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        cooked,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let raw = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
-                        self::fields::TplElementField::Raw,
-                    ));
-                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
-                        raw,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let cooked =
+                    { <Option<swc_atoms::Atom> as FoldWith<V>>::fold_with(cooked, visitor) };
+                let raw = { <swc_atoms::Atom as FoldWith<V>>::fold_with(raw, visitor) };
                 TplElement {
                     span,
                     tail,
@@ -132470,15 +105249,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TplElement {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TruePlusMinus {
-    #[doc = "Calls [FoldAstPath`::fold_true_plus_minus`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_true_plus_minus(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TruePlusMinus {
+    #[doc = "Calls [Fold`::fold_true_plus_minus`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_true_plus_minus(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TruePlusMinus::True => TruePlusMinus::True,
             TruePlusMinus::Plus => TruePlusMinus::Plus,
@@ -132486,15 +105263,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TruePlusMinus {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TryStmt {
-    #[doc = "Calls [FoldAstPath`::fold_try_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_try_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TryStmt {
+    #[doc = "Calls [Fold`::fold_try_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_try_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TryStmt {
                 span,
@@ -132502,43 +105277,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TryStmt {
                 handler,
                 finalizer,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let block = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Block));
-                    <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
-                        block,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let handler = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Handler));
-                    <Option<CatchClause> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        handler,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let finalizer = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TryStmt(
-                        self::fields::TryStmtField::Finalizer,
-                    ));
-                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        finalizer,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let block = { <BlockStmt as FoldWith<V>>::fold_with(block, visitor) };
+                let handler = { <Option<CatchClause> as FoldWith<V>>::fold_with(handler, visitor) };
+                let finalizer =
+                    { <Option<BlockStmt> as FoldWith<V>>::fold_with(finalizer, visitor) };
                 TryStmt {
                     span,
                     block,
@@ -132549,85 +105292,38 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TryStmt {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsArrayType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_array_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_array_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsArrayType {
+    #[doc = "Calls [Fold`::fold_ts_array_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_array_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsArrayType { span, elem_type } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
-                        self::fields::TsArrayTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let elem_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
-                        self::fields::TsArrayTypeField::ElemType,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        elem_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let elem_type = { <Box<TsType> as FoldWith<V>>::fold_with(elem_type, visitor) };
                 TsArrayType { span, elem_type }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsAsExpr {
-    #[doc = "Calls [FoldAstPath`::fold_ts_as_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_as_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsAsExpr {
+    #[doc = "Calls [Fold`::fold_ts_as_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_as_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsAsExpr {
                 span,
                 expr,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Expr));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsAsExpr(
-                        self::fields::TsAsExprField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsAsExpr {
                     span,
                     expr,
@@ -132637,15 +105333,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsAsExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsCallSignatureDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_call_signature_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_call_signature_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsCallSignatureDecl {
+    #[doc = "Calls [Fold`::fold_ts_call_signature_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_call_signature_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsCallSignatureDecl {
                 span,
@@ -132653,45 +105347,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsCallSignatureDecl {
                 type_ann,
                 type_params,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
-                        self::fields::TsCallSignatureDeclField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
                 TsCallSignatureDecl {
                     span,
@@ -132703,15 +105364,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsCallSignatureDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConditionalType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_conditional_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_conditional_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsConditionalType {
+    #[doc = "Calls [Fold`::fold_ts_conditional_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_conditional_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsConditionalType {
                 span,
@@ -132720,56 +105379,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConditionalType {
                 true_type,
                 false_type,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let check_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::CheckType,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        check_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let extends_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::ExtendsType,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        extends_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let true_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::TrueType,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        true_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let false_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
-                        self::fields::TsConditionalTypeField::FalseType,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        false_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let check_type = { <Box<TsType> as FoldWith<V>>::fold_with(check_type, visitor) };
+                let extends_type =
+                    { <Box<TsType> as FoldWith<V>>::fold_with(extends_type, visitor) };
+                let true_type = { <Box<TsType> as FoldWith<V>>::fold_with(true_type, visitor) };
+                let false_type = { <Box<TsType> as FoldWith<V>>::fold_with(false_type, visitor) };
                 TsConditionalType {
                     span,
                     check_type,
@@ -132781,51 +105396,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConditionalType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstAssertion {
-    #[doc = "Calls [FoldAstPath`::fold_ts_const_assertion`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_const_assertion(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsConstAssertion {
+    #[doc = "Calls [Fold`::fold_ts_const_assertion`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_const_assertion(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsConstAssertion { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
-                        self::fields::TsConstAssertionField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
-                        self::fields::TsConstAssertionField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 TsConstAssertion { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructSignatureDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_construct_signature_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_construct_signature_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsConstructSignatureDecl {
+    #[doc = "Calls [Fold`::fold_ts_construct_signature_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_construct_signature_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsConstructSignatureDecl {
                 span,
@@ -132833,49 +105426,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructSignatureDecl {
                 type_ann,
                 type_params,
             } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::Params(usize::MAX),
-                        ));
-                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::TypeAnn,
-                        ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 let type_params = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
-                            self::fields::TsConstructSignatureDeclField::TypeParams,
-                        ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
                 TsConstructSignatureDecl {
                     span,
@@ -132887,15 +105443,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructSignatureDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructorType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_constructor_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_constructor_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsConstructorType {
+    #[doc = "Calls [Fold`::fold_ts_constructor_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_constructor_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsConstructorType {
                 span,
@@ -132904,46 +105458,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructorType {
                 type_ann,
                 is_abstract,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
-                        self::fields::TsConstructorTypeField::TypeAnn,
-                    ));
-                    <Box<TsTypeAnn> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
+                let type_ann = { <Box<TsTypeAnn> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsConstructorType {
                     span,
                     params,
@@ -132951,54 +105471,36 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructorType {
                     type_ann,
                     is_abstract,
                 }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEntityName {
-    #[doc = "Calls [FoldAstPath`::fold_ts_entity_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_entity_name(visitor, self, __ast_path)
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for TsEntityName {
+    #[doc = "Calls [Fold`::fold_ts_entity_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_entity_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsEntityName::TsQualifiedName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
-                    self::fields::TsEntityNameField::TsQualifiedName,
-                ));
-                let _field_0 = <Box<TsQualifiedName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<TsQualifiedName> as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsEntityName::TsQualifiedName { 0: _field_0 }
             }
             TsEntityName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
-                    self::fields::TsEntityNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsEntityName::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_enum_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_enum_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsEnumDecl {
+    #[doc = "Calls [Fold`::fold_ts_enum_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_enum_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsEnumDecl {
                 span,
@@ -133007,31 +105509,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumDecl {
                 id,
                 members,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
-                        self::fields::TsEnumDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsEnumDecl(self::fields::TsEnumDeclField::Id));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
-                };
-                let members = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
-                        self::fields::TsEnumDeclField::Members(usize::MAX),
-                    ));
-                    <Vec<TsEnumMember> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        members,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
+                let members = { <Vec<TsEnumMember> as FoldWith<V>>::fold_with(members, visitor) };
                 TsEnumDecl {
                     span,
                     declare,
@@ -133043,163 +105523,77 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumMember {
-    #[doc = "Calls [FoldAstPath`::fold_ts_enum_member`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_enum_member(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsEnumMember {
+    #[doc = "Calls [Fold`::fold_ts_enum_member`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_enum_member(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsEnumMember { span, id, init } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
-                        self::fields::TsEnumMemberField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
-                        self::fields::TsEnumMemberField::Id,
-                    ));
-                    <TsEnumMemberId as FoldWithAstPath<V>>::fold_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let init = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
-                        self::fields::TsEnumMemberField::Init,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <TsEnumMemberId as FoldWith<V>>::fold_with(id, visitor) };
+                let init = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(init, visitor) };
                 TsEnumMember { span, id, init }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumMemberId {
-    #[doc = "Calls [FoldAstPath`::fold_ts_enum_member_id`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_enum_member_id(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsEnumMemberId {
+    #[doc = "Calls [Fold`::fold_ts_enum_member_id`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_enum_member_id(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsEnumMemberId::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
-                    self::fields::TsEnumMemberIdField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsEnumMemberId::Ident { 0: _field_0 }
             }
             TsEnumMemberId::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
-                    self::fields::TsEnumMemberIdField::Str,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsEnumMemberId::Str { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsExportAssignment {
-    #[doc = "Calls [FoldAstPath`::fold_ts_export_assignment`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_export_assignment(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsExportAssignment {
+    #[doc = "Calls [Fold`::fold_ts_export_assignment`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_export_assignment(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsExportAssignment { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
-                        self::fields::TsExportAssignmentField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
-                        self::fields::TsExportAssignmentField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 TsExportAssignment { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsExprWithTypeArgs {
-    #[doc = "Calls [FoldAstPath`::fold_ts_expr_with_type_args`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_expr_with_type_args(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsExprWithTypeArgs {
+    #[doc = "Calls [Fold`::fold_ts_expr_with_type_args`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_expr_with_type_args(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsExprWithTypeArgs {
                 span,
                 expr,
                 type_args,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
-                        self::fields::TsExprWithTypeArgsField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
-                        self::fields::TsExprWithTypeArgsField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
-                        self::fields::TsExprWithTypeArgsField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_args, visitor,
+                    )
                 };
                 TsExprWithTypeArgs {
                     span,
@@ -133210,138 +105604,75 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsExprWithTypeArgs {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsExternalModuleRef {
-    #[doc = "Calls [FoldAstPath`::fold_ts_external_module_ref`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_external_module_ref(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsExternalModuleRef {
+    #[doc = "Calls [Fold`::fold_ts_external_module_ref`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_external_module_ref(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsExternalModuleRef { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
-                        self::fields::TsExternalModuleRefField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
-                        self::fields::TsExternalModuleRefField::Expr,
-                    ));
-                    <Str as FoldWithAstPath<V>>::fold_with_ast_path(expr, visitor, &mut *__ast_path)
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Str as FoldWith<V>>::fold_with(expr, visitor) };
                 TsExternalModuleRef { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnOrConstructorType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_fn_or_constructor_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_fn_or_constructor_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsFnOrConstructorType {
+    #[doc = "Calls [Fold`::fold_ts_fn_or_constructor_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_fn_or_constructor_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsFnOrConstructorType::TsFnType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
-                    self::fields::TsFnOrConstructorTypeField::TsFnType,
-                ));
-                let _field_0 = <TsFnType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsFnType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsFnOrConstructorType::TsFnType { 0: _field_0 }
             }
             TsFnOrConstructorType::TsConstructorType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
-                    self::fields::TsFnOrConstructorTypeField::TsConstructorType,
-                ));
-                let _field_0 = <TsConstructorType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsConstructorType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsFnOrConstructorType::TsConstructorType { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnParam {
-    #[doc = "Calls [FoldAstPath`::fold_ts_fn_param`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_fn_param(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsFnParam {
+    #[doc = "Calls [Fold`::fold_ts_fn_param`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_fn_param(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsFnParam::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
-                    self::fields::TsFnParamField::Ident,
-                ));
-                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsFnParam::Ident { 0: _field_0 }
             }
             TsFnParam::Array { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
-                    self::fields::TsFnParamField::Array,
-                ));
-                let _field_0 = <ArrayPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ArrayPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsFnParam::Array { 0: _field_0 }
             }
             TsFnParam::Rest { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsFnParam(self::fields::TsFnParamField::Rest));
-                let _field_0 = <RestPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <RestPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsFnParam::Rest { 0: _field_0 }
             }
             TsFnParam::Object { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
-                    self::fields::TsFnParamField::Object,
-                ));
-                let _field_0 = <ObjectPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <ObjectPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsFnParam::Object { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_fn_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_fn_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsFnType {
+    #[doc = "Calls [Fold`::fold_ts_fn_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_fn_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsFnType {
                 span,
@@ -133349,45 +105680,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnType {
                 type_params,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsFnType(self::fields::TsFnTypeField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
-                        self::fields::TsFnTypeField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
-                        self::fields::TsFnTypeField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
-                        self::fields::TsFnTypeField::TypeAnn,
-                    ));
-                    <Box<TsTypeAnn> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
+                let type_ann = { <Box<TsTypeAnn> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsFnType {
                     span,
                     params,
@@ -133398,15 +105696,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsGetterSignature {
-    #[doc = "Calls [FoldAstPath`::fold_ts_getter_signature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_getter_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsGetterSignature {
+    #[doc = "Calls [Fold`::fold_ts_getter_signature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_getter_signature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsGetterSignature {
                 span,
@@ -133414,36 +105710,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsGetterSignature {
                 computed,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
-                        self::fields::TsGetterSignatureField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
-                        self::fields::TsGetterSignatureField::Key,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
-                        self::fields::TsGetterSignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsGetterSignature {
                     span,
                     key,
@@ -133454,15 +105724,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsGetterSignature {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportEqualsDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_import_equals_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_import_equals_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsImportEqualsDecl {
+    #[doc = "Calls [Fold`::fold_ts_import_equals_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_import_equals_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsImportEqualsDecl {
                 span,
@@ -133471,32 +105739,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportEqualsDecl {
                 id,
                 module_ref,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
-                        self::fields::TsImportEqualsDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
-                        self::fields::TsImportEqualsDeclField::Id,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
-                };
-                let module_ref = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
-                        self::fields::TsImportEqualsDeclField::ModuleRef,
-                    ));
-                    <TsModuleRef as FoldWithAstPath<V>>::fold_with_ast_path(
-                        module_ref,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
+                let module_ref = { <TsModuleRef as FoldWith<V>>::fold_with(module_ref, visitor) };
                 TsImportEqualsDecl {
                     span,
                     is_export,
@@ -133508,15 +105753,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportEqualsDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_import_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_import_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsImportType {
+    #[doc = "Calls [Fold`::fold_ts_import_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_import_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsImportType {
                 span,
@@ -133524,37 +105767,14 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportType {
                 qualifier,
                 type_args,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::Arg,
-                    ));
-                    <Str as FoldWithAstPath<V>>::fold_with_ast_path(arg, visitor, &mut *__ast_path)
-                };
-                let qualifier = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::Qualifier,
-                    ));
-                    <Option<TsEntityName> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        qualifier,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let arg = { <Str as FoldWith<V>>::fold_with(arg, visitor) };
+                let qualifier =
+                    { <Option<TsEntityName> as FoldWith<V>>::fold_with(qualifier, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
-                        self::fields::TsImportTypeField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_args, visitor,
+                    )
                 };
                 TsImportType {
                     span,
@@ -133566,15 +105786,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexSignature {
-    #[doc = "Calls [FoldAstPath`::fold_ts_index_signature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_index_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsIndexSignature {
+    #[doc = "Calls [Fold`::fold_ts_index_signature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_index_signature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsIndexSignature {
                 params,
@@ -133583,36 +105801,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexSignature {
                 is_static,
                 span,
             } => {
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
-                        self::fields::TsIndexSignatureField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
-                        self::fields::TsIndexSignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
-                        self::fields::TsIndexSignatureField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 TsIndexSignature {
                     params,
                     type_ann,
@@ -133624,15 +105816,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexSignature {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexedAccessType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_indexed_access_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_indexed_access_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsIndexedAccessType {
+    #[doc = "Calls [Fold`::fold_ts_indexed_access_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_indexed_access_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsIndexedAccessType {
                 span,
@@ -133640,36 +105830,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexedAccessType {
                 obj_type,
                 index_type,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
-                        self::fields::TsIndexedAccessTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let obj_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
-                        self::fields::TsIndexedAccessTypeField::ObjType,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        obj_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let index_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
-                        self::fields::TsIndexedAccessTypeField::IndexType,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        index_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let obj_type = { <Box<TsType> as FoldWith<V>>::fold_with(obj_type, visitor) };
+                let index_type = { <Box<TsType> as FoldWith<V>>::fold_with(index_type, visitor) };
                 TsIndexedAccessType {
                     span,
                     readonly,
@@ -133680,86 +105843,39 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexedAccessType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInferType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_infer_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_infer_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsInferType {
+    #[doc = "Calls [Fold`::fold_ts_infer_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_infer_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsInferType { span, type_param } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
-                        self::fields::TsInferTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_param = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
-                        self::fields::TsInferTypeField::TypeParam,
-                    ));
-                    <TsTypeParam as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let type_param = { <TsTypeParam as FoldWith<V>>::fold_with(type_param, visitor) };
                 TsInferType { span, type_param }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInstantiation {
-    #[doc = "Calls [FoldAstPath`::fold_ts_instantiation`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_instantiation(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsInstantiation {
+    #[doc = "Calls [Fold`::fold_ts_instantiation`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_instantiation(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsInstantiation {
                 span,
                 expr,
                 type_args,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
-                        self::fields::TsInstantiationField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
-                        self::fields::TsInstantiationField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
-                        self::fields::TsInstantiationField::TypeArgs,
-                    ));
-                    <Box<TsTypeParamInstantiation> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_args,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Box<TsTypeParamInstantiation> as FoldWith<V>>::fold_with(type_args, visitor)
                 };
                 TsInstantiation {
                     span,
@@ -133770,51 +105886,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInstantiation {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInterfaceBody {
-    #[doc = "Calls [FoldAstPath`::fold_ts_interface_body`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_interface_body(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsInterfaceBody {
+    #[doc = "Calls [Fold`::fold_ts_interface_body`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_interface_body(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsInterfaceBody { span, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
-                        self::fields::TsInterfaceBodyField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
-                        self::fields::TsInterfaceBodyField::Body(usize::MAX),
-                    ));
-                    <Vec<TsTypeElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let body = { <Vec<TsTypeElement> as FoldWith<V>>::fold_with(body, visitor) };
                 TsInterfaceBody { span, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInterfaceDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_interface_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_interface_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsInterfaceDecl {
+    #[doc = "Calls [Fold`::fold_ts_interface_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_interface_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsInterfaceDecl {
                 span,
@@ -133824,52 +105918,14 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInterfaceDecl {
                 extends,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Id,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let extends = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Extends(usize::MAX),
-                    ));
-                    <Vec<TsExprWithTypeArgs> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        extends,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
-                        self::fields::TsInterfaceDeclField::Body,
-                    ));
-                    <TsInterfaceBody as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
+                let extends =
+                    { <Vec<TsExprWithTypeArgs> as FoldWith<V>>::fold_with(extends, visitor) };
+                let body = { <TsInterfaceBody as FoldWith<V>>::fold_with(body, visitor) };
                 TsInterfaceDecl {
                     span,
                     id,
@@ -133882,87 +105938,45 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInterfaceDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIntersectionType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_intersection_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_intersection_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsIntersectionType {
+    #[doc = "Calls [Fold`::fold_ts_intersection_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_intersection_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsIntersectionType { span, types } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
-                        self::fields::TsIntersectionTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let types = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
-                        self::fields::TsIntersectionTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let types = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(types, visitor) };
                 TsIntersectionType { span, types }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsKeywordType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_keyword_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_keyword_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsKeywordType {
+    #[doc = "Calls [Fold`::fold_ts_keyword_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_keyword_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsKeywordType { span, kind } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
-                        self::fields::TsKeywordTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let kind = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
-                        self::fields::TsKeywordTypeField::Kind,
-                    ));
-                    <TsKeywordTypeKind as FoldWithAstPath<V>>::fold_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let kind = { <TsKeywordTypeKind as FoldWith<V>>::fold_with(kind, visitor) };
                 TsKeywordType { span, kind }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsKeywordTypeKind {
-    #[doc = "Calls [FoldAstPath`::fold_ts_keyword_type_kind`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_keyword_type_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsKeywordTypeKind {
+    #[doc = "Calls [Fold`::fold_ts_keyword_type_kind`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_keyword_type_kind(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsKeywordTypeKind::TsAnyKeyword => TsKeywordTypeKind::TsAnyKeyword,
             TsKeywordTypeKind::TsUnknownKeyword => TsKeywordTypeKind::TsUnknownKeyword,
@@ -133980,181 +105994,79 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsKeywordTypeKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsLit {
-    #[doc = "Calls [FoldAstPath`::fold_ts_lit`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsLit {
+    #[doc = "Calls [Fold`::fold_ts_lit`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_lit(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsLit::Number { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Number));
-                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Number as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsLit::Number { 0: _field_0 }
             }
             TsLit::Str { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Str));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsLit::Str { 0: _field_0 }
             }
             TsLit::Bool { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Bool));
-                let _field_0 = <Bool as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Bool as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsLit::Bool { 0: _field_0 }
             }
             TsLit::BigInt { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::BigInt));
-                let _field_0 = <BigInt as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BigInt as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsLit::BigInt { 0: _field_0 }
             }
             TsLit::Tpl { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Tpl));
-                let _field_0 = <TsTplLitType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTplLitType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsLit::Tpl { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsLitType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_lit_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_lit_type(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            TsLitType { span, lit } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let lit = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Lit));
-                    <TsLit as FoldWithAstPath<V>>::fold_with_ast_path(
-                        lit,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                TsLitType { span, lit }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsMappedType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_mapped_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_mapped_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsLitType {
+    #[doc = "Calls [Fold`::fold_ts_lit_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_lit_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
-            TsMappedType {
-                span,
-                readonly,
-                type_param,
-                name_type,
-                optional,
-                type_ann,
-            } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let readonly = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::Readonly,
-                    ));
-                    <Option<TruePlusMinus> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        readonly,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_param = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::TypeParam,
-                    ));
-                    <TsTypeParam as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name_type = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::NameType,
-                    ));
-                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name_type,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let optional = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::Optional,
-                    ));
-                    <Option<TruePlusMinus> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        optional,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
-                        self::fields::TsMappedTypeField::TypeAnn,
-                    ));
-                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+            TsLitType { span, lit } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let lit = { <TsLit as FoldWith<V>>::fold_with(lit, visitor) };
+                TsLitType { span, lit }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for TsMappedType {
+    #[doc = "Calls [Fold`::fold_ts_mapped_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_mapped_type(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            TsMappedType {
+                span,
+                readonly,
+                type_param,
+                name_type,
+                optional,
+                type_ann,
+            } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let readonly =
+                    { <Option<TruePlusMinus> as FoldWith<V>>::fold_with(readonly, visitor) };
+                let type_param = { <TsTypeParam as FoldWith<V>>::fold_with(type_param, visitor) };
+                let name_type =
+                    { <Option<Box<TsType>> as FoldWith<V>>::fold_with(name_type, visitor) };
+                let optional =
+                    { <Option<TruePlusMinus> as FoldWith<V>>::fold_with(optional, visitor) };
+                let type_ann =
+                    { <Option<Box<TsType>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsMappedType {
                     span,
                     readonly,
@@ -134167,15 +106079,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsMappedType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsMethodSignature {
-    #[doc = "Calls [FoldAstPath`::fold_ts_method_signature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_method_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsMethodSignature {
+    #[doc = "Calls [Fold`::fold_ts_method_signature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_method_signature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsMethodSignature {
                 span,
@@ -134186,55 +106096,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsMethodSignature {
                 type_ann,
                 type_params,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::Key,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::Params(usize::MAX),
-                    ));
-                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
+                let params = { <Vec<TsFnParam> as FoldWith<V>>::fold_with(params, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
-                        self::fields::TsMethodSignatureField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
                 TsMethodSignature {
                     span,
@@ -134249,51 +106117,29 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsMethodSignature {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleBlock {
-    #[doc = "Calls [FoldAstPath`::fold_ts_module_block`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_module_block(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsModuleBlock {
+    #[doc = "Calls [Fold`::fold_ts_module_block`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_module_block(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsModuleBlock { span, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
-                        self::fields::TsModuleBlockField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
-                        self::fields::TsModuleBlockField::Body(usize::MAX),
-                    ));
-                    <Vec<ModuleItem> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let body = { <Vec<ModuleItem> as FoldWith<V>>::fold_with(body, visitor) };
                 TsModuleBlock { span, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_module_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_module_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsModuleDecl {
+    #[doc = "Calls [Fold`::fold_ts_module_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_module_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsModuleDecl {
                 span,
@@ -134302,36 +106148,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleDecl {
                 id,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
-                        self::fields::TsModuleDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
-                        self::fields::TsModuleDeclField::Id,
-                    ));
-                    <TsModuleName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        id,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
-                        self::fields::TsModuleDeclField::Body,
-                    ));
-                    <Option<TsNamespaceBody> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <TsModuleName as FoldWith<V>>::fold_with(id, visitor) };
+                let body = { <Option<TsNamespaceBody> as FoldWith<V>>::fold_with(body, visitor) };
                 TsModuleDecl {
                     span,
                     declare,
@@ -134343,120 +106162,70 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleName {
-    #[doc = "Calls [FoldAstPath`::fold_ts_module_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_module_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsModuleName {
+    #[doc = "Calls [Fold`::fold_ts_module_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_module_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsModuleName::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
-                    self::fields::TsModuleNameField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsModuleName::Ident { 0: _field_0 }
             }
             TsModuleName::Str { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
-                    self::fields::TsModuleNameField::Str,
-                ));
-                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Str as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsModuleName::Str { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleRef {
-    #[doc = "Calls [FoldAstPath`::fold_ts_module_ref`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_module_ref(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsModuleRef {
+    #[doc = "Calls [Fold`::fold_ts_module_ref`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_module_ref(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsModuleRef::TsEntityName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
-                    self::fields::TsModuleRefField::TsEntityName,
-                ));
-                let _field_0 = <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsEntityName as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsModuleRef::TsEntityName { 0: _field_0 }
             }
             TsModuleRef::TsExternalModuleRef { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
-                    self::fields::TsModuleRefField::TsExternalModuleRef,
-                ));
-                let _field_0 = <TsExternalModuleRef as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsExternalModuleRef as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsModuleRef::TsExternalModuleRef { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceBody {
-    #[doc = "Calls [FoldAstPath`::fold_ts_namespace_body`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_namespace_body(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsNamespaceBody {
+    #[doc = "Calls [Fold`::fold_ts_namespace_body`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_namespace_body(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsNamespaceBody::TsModuleBlock { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
-                    self::fields::TsNamespaceBodyField::TsModuleBlock,
-                ));
-                let _field_0 = <TsModuleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsModuleBlock as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsNamespaceBody::TsModuleBlock { 0: _field_0 }
             }
             TsNamespaceBody::TsNamespaceDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
-                    self::fields::TsNamespaceBodyField::TsNamespaceDecl,
-                ));
-                let _field_0 = <TsNamespaceDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsNamespaceDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsNamespaceBody::TsNamespaceDecl { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_namespace_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_namespace_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsNamespaceDecl {
+    #[doc = "Calls [Fold`::fold_ts_namespace_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_namespace_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsNamespaceDecl {
                 span,
@@ -134465,32 +106234,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceDecl {
                 id,
                 body,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
-                        self::fields::TsNamespaceDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
-                        self::fields::TsNamespaceDeclField::Id,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
-                };
-                let body = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
-                        self::fields::TsNamespaceDeclField::Body,
-                    ));
-                    <Box<TsNamespaceBody> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
+                let body = { <Box<TsNamespaceBody> as FoldWith<V>>::fold_with(body, visitor) };
                 TsNamespaceDecl {
                     span,
                     declare,
@@ -134502,121 +106248,61 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceExportDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_namespace_export_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_namespace_export_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsNamespaceExportDecl {
+    #[doc = "Calls [Fold`::fold_ts_namespace_export_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_namespace_export_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsNamespaceExportDecl { span, id } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
-                            self::fields::TsNamespaceExportDeclField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
-                            self::fields::TsNamespaceExportDeclField::Id,
-                        ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
                 TsNamespaceExportDecl { span, id }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNonNullExpr {
-    #[doc = "Calls [FoldAstPath`::fold_ts_non_null_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_non_null_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsNonNullExpr {
+    #[doc = "Calls [Fold`::fold_ts_non_null_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_non_null_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsNonNullExpr { span, expr } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
-                        self::fields::TsNonNullExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
-                        self::fields::TsNonNullExprField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
                 TsNonNullExpr { span, expr }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsOptionalType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_optional_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_optional_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsOptionalType {
+    #[doc = "Calls [Fold`::fold_ts_optional_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_optional_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsOptionalType { span, type_ann } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
-                        self::fields::TsOptionalTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
-                        self::fields::TsOptionalTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsOptionalType { span, type_ann }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParamProp {
-    #[doc = "Calls [FoldAstPath`::fold_ts_param_prop`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_param_prop(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsParamProp {
+    #[doc = "Calls [Fold`::fold_ts_param_prop`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_param_prop(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsParamProp {
                 span,
@@ -134626,46 +106312,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParamProp {
                 readonly,
                 param,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decorators = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Decorators(usize::MAX),
-                    ));
-                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decorators,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let accessibility = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Accessibility,
-                    ));
-                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        accessibility,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let param = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
-                        self::fields::TsParamPropField::Param,
-                    ));
-                    <TsParamPropParam as FoldWithAstPath<V>>::fold_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let decorators =
+                    { <Vec<Decorator> as FoldWith<V>>::fold_with(decorators, visitor) };
+                let accessibility =
+                    { <Option<Accessibility> as FoldWith<V>>::fold_with(accessibility, visitor) };
+                let param = { <TsParamPropParam as FoldWith<V>>::fold_with(param, visitor) };
                 TsParamProp {
                     span,
                     decorators,
@@ -134678,86 +106330,48 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParamProp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParamPropParam {
-    #[doc = "Calls [FoldAstPath`::fold_ts_param_prop_param`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_param_prop_param(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsParamPropParam {
+    #[doc = "Calls [Fold`::fold_ts_param_prop_param`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_param_prop_param(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsParamPropParam::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
-                    self::fields::TsParamPropParamField::Ident,
-                ));
-                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <BindingIdent as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsParamPropParam::Ident { 0: _field_0 }
             }
             TsParamPropParam::Assign { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
-                    self::fields::TsParamPropParamField::Assign,
-                ));
-                let _field_0 = <AssignPat as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <AssignPat as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsParamPropParam::Assign { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParenthesizedType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_parenthesized_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_parenthesized_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsParenthesizedType {
+    #[doc = "Calls [Fold`::fold_ts_parenthesized_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_parenthesized_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsParenthesizedType { span, type_ann } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
-                        self::fields::TsParenthesizedTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
-                        self::fields::TsParenthesizedTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsParenthesizedType { span, type_ann }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsPropertySignature {
-    #[doc = "Calls [FoldAstPath`::fold_ts_property_signature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_property_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsPropertySignature {
+    #[doc = "Calls [Fold`::fold_ts_property_signature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_property_signature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsPropertySignature {
                 span,
@@ -134767,36 +106381,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsPropertySignature {
                 optional,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
-                        self::fields::TsPropertySignatureField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
-                        self::fields::TsPropertySignatureField::Key,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
-                        self::fields::TsPropertySignatureField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsPropertySignature {
                     span,
                     readonly,
@@ -134809,133 +106397,55 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsPropertySignature {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsQualifiedName {
-    #[doc = "Calls [FoldAstPath`::fold_ts_qualified_name`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_qualified_name(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsQualifiedName {
+    #[doc = "Calls [Fold`::fold_ts_qualified_name`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_qualified_name(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsQualifiedName { span, left, right } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
-                        self::fields::TsQualifiedNameField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let left = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
-                        self::fields::TsQualifiedNameField::Left,
-                    ));
-                    <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        left,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let right = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
-                        self::fields::TsQualifiedNameField::Right,
-                    ));
-                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        right,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let left = { <TsEntityName as FoldWith<V>>::fold_with(left, visitor) };
+                let right = { <IdentName as FoldWith<V>>::fold_with(right, visitor) };
                 TsQualifiedName { span, left, right }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsRestType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_rest_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_rest_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsRestType {
+    #[doc = "Calls [Fold`::fold_ts_rest_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_rest_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsRestType { span, type_ann } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
-                        self::fields::TsRestTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
-                        self::fields::TsRestTypeField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsRestType { span, type_ann }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsSatisfiesExpr {
-    #[doc = "Calls [FoldAstPath`::fold_ts_satisfies_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_satisfies_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsSatisfiesExpr {
+    #[doc = "Calls [Fold`::fold_ts_satisfies_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_satisfies_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsSatisfiesExpr {
                 span,
                 expr,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
-                        self::fields::TsSatisfiesExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
-                        self::fields::TsSatisfiesExprField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
-                        self::fields::TsSatisfiesExprField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsSatisfiesExpr {
                     span,
                     expr,
@@ -134945,15 +106455,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsSatisfiesExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsSetterSignature {
-    #[doc = "Calls [FoldAstPath`::fold_ts_setter_signature`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_setter_signature(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsSetterSignature {
+    #[doc = "Calls [Fold`::fold_ts_setter_signature`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_setter_signature(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsSetterSignature {
                 span,
@@ -134961,36 +106469,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsSetterSignature {
                 computed,
                 param,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
-                        self::fields::TsSetterSignatureField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let key = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
-                        self::fields::TsSetterSignatureField::Key,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        key,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let param = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
-                        self::fields::TsSetterSignatureField::Param,
-                    ));
-                    <TsFnParam as FoldWithAstPath<V>>::fold_with_ast_path(
-                        param,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let key = { <Box<Expr> as FoldWith<V>>::fold_with(key, visitor) };
+                let param = { <TsFnParam as FoldWith<V>>::fold_with(param, visitor) };
                 TsSetterSignature {
                     span,
                     key,
@@ -135001,112 +106482,56 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsSetterSignature {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsThisType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_this_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_this_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsThisType {
+    #[doc = "Calls [Fold`::fold_ts_this_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_this_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsThisType { span } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisType(
-                        self::fields::TsThisTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
                 TsThisType { span }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsThisTypeOrIdent {
-    #[doc = "Calls [FoldAstPath`::fold_ts_this_type_or_ident`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_this_type_or_ident(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsThisTypeOrIdent {
+    #[doc = "Calls [Fold`::fold_ts_this_type_or_ident`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_this_type_or_ident(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsThisTypeOrIdent::TsThisType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
-                    self::fields::TsThisTypeOrIdentField::TsThisType,
-                ));
-                let _field_0 = <TsThisType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsThisType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsThisTypeOrIdent::TsThisType { 0: _field_0 }
             }
             TsThisTypeOrIdent::Ident { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
-                    self::fields::TsThisTypeOrIdentField::Ident,
-                ));
-                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Ident as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsThisTypeOrIdent::Ident { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTplLitType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_tpl_lit_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_tpl_lit_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTplLitType {
+    #[doc = "Calls [Fold`::fold_ts_tpl_lit_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_tpl_lit_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTplLitType {
                 span,
                 types,
                 quasis,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
-                        self::fields::TsTplLitTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let types = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
-                        self::fields::TsTplLitTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let quasis = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
-                        self::fields::TsTplLitTypeField::Quasis(usize::MAX),
-                    ));
-                    <Vec<TplElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        quasis,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let types = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(types, visitor) };
+                let quasis = { <Vec<TplElement> as FoldWith<V>>::fold_with(quasis, visitor) };
                 TsTplLitType {
                     span,
                     types,
@@ -135116,326 +106541,139 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTplLitType {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTupleElement {
-    #[doc = "Calls [FoldAstPath`::fold_ts_tuple_element`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_tuple_element(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTupleElement {
+    #[doc = "Calls [Fold`::fold_ts_tuple_element`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_tuple_element(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTupleElement { span, label, ty } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
-                        self::fields::TsTupleElementField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let label = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
-                        self::fields::TsTupleElementField::Label,
-                    ));
-                    <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        label,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ty = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
-                        self::fields::TsTupleElementField::Ty,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ty,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let label = { <Option<Pat> as FoldWith<V>>::fold_with(label, visitor) };
+                let ty = { <Box<TsType> as FoldWith<V>>::fold_with(ty, visitor) };
                 TsTupleElement { span, label, ty }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTupleType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_tuple_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_tuple_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTupleType {
+    #[doc = "Calls [Fold`::fold_ts_tuple_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_tuple_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTupleType { span, elem_types } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
-                        self::fields::TsTupleTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let elem_types = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
-                        self::fields::TsTupleTypeField::ElemTypes(usize::MAX),
-                    ));
-                    <Vec<TsTupleElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        elem_types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let elem_types =
+                    { <Vec<TsTupleElement> as FoldWith<V>>::fold_with(elem_types, visitor) };
                 TsTupleType { span, elem_types }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsType {
+    #[doc = "Calls [Fold`::fold_ts_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsType::TsKeywordType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsKeywordType,
-                ));
-                let _field_0 = <TsKeywordType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsKeywordType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsKeywordType { 0: _field_0 }
             }
             TsType::TsThisType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsThisType));
-                let _field_0 = <TsThisType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsThisType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsThisType { 0: _field_0 }
             }
             TsType::TsFnOrConstructorType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsFnOrConstructorType,
-                ));
-                let _field_0 = <TsFnOrConstructorType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsFnOrConstructorType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsFnOrConstructorType { 0: _field_0 }
             }
             TsType::TsTypeRef { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeRef));
-                let _field_0 = <TsTypeRef as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTypeRef as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsTypeRef { 0: _field_0 }
             }
             TsType::TsTypeQuery { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTypeQuery,
-                ));
-                let _field_0 = <TsTypeQuery as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTypeQuery as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsTypeQuery { 0: _field_0 }
             }
             TsType::TsTypeLit { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeLit));
-                let _field_0 = <TsTypeLit as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTypeLit as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsTypeLit { 0: _field_0 }
             }
             TsType::TsArrayType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsArrayType,
-                ));
-                let _field_0 = <TsArrayType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsArrayType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsArrayType { 0: _field_0 }
             }
             TsType::TsTupleType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTupleType,
-                ));
-                let _field_0 = <TsTupleType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTupleType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsTupleType { 0: _field_0 }
             }
             TsType::TsOptionalType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsOptionalType,
-                ));
-                let _field_0 = <TsOptionalType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                TsType::TsOptionalType { 0: _field_0 }
-            }
-            TsType::TsRestType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsRestType));
-                let _field_0 = <TsRestType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsOptionalType as FoldWith<V>>::fold_with(_field_0, visitor);
+                TsType::TsOptionalType { 0: _field_0 }
+            }
+            TsType::TsRestType { 0: _field_0 } => {
+                let _field_0 = <TsRestType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsRestType { 0: _field_0 }
             }
             TsType::TsUnionOrIntersectionType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsUnionOrIntersectionType,
-                ));
                 let _field_0 =
-                    <TsUnionOrIntersectionType as FoldWithAstPath<V>>::fold_with_ast_path(
-                        _field_0,
-                        visitor,
-                        &mut *__ast_path,
-                    );
+                    <TsUnionOrIntersectionType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsUnionOrIntersectionType { 0: _field_0 }
             }
             TsType::TsConditionalType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsConditionalType,
-                ));
-                let _field_0 = <TsConditionalType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsConditionalType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsConditionalType { 0: _field_0 }
             }
             TsType::TsInferType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsInferType,
-                ));
-                let _field_0 = <TsInferType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsInferType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsInferType { 0: _field_0 }
             }
             TsType::TsParenthesizedType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsParenthesizedType,
-                ));
-                let _field_0 = <TsParenthesizedType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsParenthesizedType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsParenthesizedType { 0: _field_0 }
             }
             TsType::TsTypeOperator { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTypeOperator,
-                ));
-                let _field_0 = <TsTypeOperator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTypeOperator as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsTypeOperator { 0: _field_0 }
             }
             TsType::TsIndexedAccessType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsIndexedAccessType,
-                ));
-                let _field_0 = <TsIndexedAccessType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsIndexedAccessType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsIndexedAccessType { 0: _field_0 }
             }
             TsType::TsMappedType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsMappedType,
-                ));
-                let _field_0 = <TsMappedType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsMappedType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsMappedType { 0: _field_0 }
             }
             TsType::TsLitType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path
-                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsLitType));
-                let _field_0 = <TsLitType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsLitType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsLitType { 0: _field_0 }
             }
             TsType::TsTypePredicate { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsTypePredicate,
-                ));
-                let _field_0 = <TsTypePredicate as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsTypePredicate as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsTypePredicate { 0: _field_0 }
             }
             TsType::TsImportType { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
-                    self::fields::TsTypeField::TsImportType,
-                ));
-                let _field_0 = <TsImportType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsImportType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsType::TsImportType { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAliasDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_alias_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_alias_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeAliasDecl {
+    #[doc = "Calls [Fold`::fold_ts_type_alias_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_alias_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeAliasDecl {
                 span,
@@ -135444,42 +106682,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAliasDecl {
                 type_params,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let id = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::Id,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let id = { <Ident as FoldWith<V>>::fold_with(id, visitor) };
                 let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::TypeParams,
-                    ));
-                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
-                        self::fields::TsTypeAliasDeclField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
+                    <Option<Box<TsTypeParamDecl>> as FoldWith<V>>::fold_with(type_params, visitor)
                 };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsTypeAliasDecl {
                     span,
                     declare,
@@ -135491,86 +106699,38 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAliasDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAnn {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_ann`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_ann(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeAnn {
+    #[doc = "Calls [Fold`::fold_ts_type_ann`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_ann(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeAnn { span, type_ann } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsTypeAnn(self::fields::TsTypeAnnField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAnn(
-                        self::fields::TsTypeAnnField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsTypeAnn { span, type_ann }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAssertion {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_assertion`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_assertion(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeAssertion {
+    #[doc = "Calls [Fold`::fold_ts_type_assertion`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_assertion(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeAssertion {
                 span,
                 expr,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
-                        self::fields::TsTypeAssertionField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
-                        self::fields::TsTypeAssertionField::Expr,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
-                        self::fields::TsTypeAssertionField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr = { <Box<Expr> as FoldWith<V>>::fold_with(expr, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsTypeAssertion {
                     span,
                     expr,
@@ -135580,186 +106740,86 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAssertion {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeElement {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_element`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_element(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeElement {
+    #[doc = "Calls [Fold`::fold_ts_type_element`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_element(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeElement::TsCallSignatureDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsCallSignatureDecl,
-                ));
-                let _field_0 = <TsCallSignatureDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsCallSignatureDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeElement::TsCallSignatureDecl { 0: _field_0 }
             }
             TsTypeElement::TsConstructSignatureDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsConstructSignatureDecl,
-                ));
-                let _field_0 = <TsConstructSignatureDecl as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 =
+                    <TsConstructSignatureDecl as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeElement::TsConstructSignatureDecl { 0: _field_0 }
             }
             TsTypeElement::TsPropertySignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsPropertySignature,
-                ));
-                let _field_0 = <TsPropertySignature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsPropertySignature as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeElement::TsPropertySignature { 0: _field_0 }
             }
             TsTypeElement::TsGetterSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsGetterSignature,
-                ));
-                let _field_0 = <TsGetterSignature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsGetterSignature as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeElement::TsGetterSignature { 0: _field_0 }
             }
             TsTypeElement::TsSetterSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsSetterSignature,
-                ));
-                let _field_0 = <TsSetterSignature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsSetterSignature as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeElement::TsSetterSignature { 0: _field_0 }
             }
             TsTypeElement::TsMethodSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsMethodSignature,
-                ));
-                let _field_0 = <TsMethodSignature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsMethodSignature as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeElement::TsMethodSignature { 0: _field_0 }
             }
             TsTypeElement::TsIndexSignature { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
-                    self::fields::TsTypeElementField::TsIndexSignature,
-                ));
-                let _field_0 = <TsIndexSignature as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsIndexSignature as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeElement::TsIndexSignature { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeLit {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_lit`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_lit(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeLit {
+    #[doc = "Calls [Fold`::fold_ts_type_lit`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_lit(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeLit { span, members } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsTypeLit(self::fields::TsTypeLitField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let members = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeLit(
-                        self::fields::TsTypeLitField::Members(usize::MAX),
-                    ));
-                    <Vec<TsTypeElement> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        members,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let members = { <Vec<TsTypeElement> as FoldWith<V>>::fold_with(members, visitor) };
                 TsTypeLit { span, members }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeOperator {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_operator`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_operator(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeOperator {
+    #[doc = "Calls [Fold`::fold_ts_type_operator`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_operator(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeOperator { span, op, type_ann } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
-                        self::fields::TsTypeOperatorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let op = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
-                        self::fields::TsTypeOperatorField::Op,
-                    ));
-                    <TsTypeOperatorOp as FoldWithAstPath<V>>::fold_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
-                        self::fields::TsTypeOperatorField::TypeAnn,
-                    ));
-                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let op = { <TsTypeOperatorOp as FoldWith<V>>::fold_with(op, visitor) };
+                let type_ann = { <Box<TsType> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsTypeOperator { span, op, type_ann }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeOperatorOp {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_operator_op`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_operator_op(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeOperatorOp {
+    #[doc = "Calls [Fold`::fold_ts_type_operator_op`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_operator_op(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeOperatorOp::KeyOf => TsTypeOperatorOp::KeyOf,
             TsTypeOperatorOp::Unique => TsTypeOperatorOp::Unique,
@@ -135767,15 +106827,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeOperatorOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParam {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_param`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_param(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeParam {
+    #[doc = "Calls [Fold`::fold_ts_type_param`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_param(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeParam {
                 span,
@@ -135786,46 +106844,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParam {
                 constraint,
                 default,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Name,
-                    ));
-                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
-                        name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let constraint = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Constraint,
-                    ));
-                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        constraint,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let default = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
-                        self::fields::TsTypeParamField::Default,
-                    ));
-                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        default,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Ident as FoldWith<V>>::fold_with(name, visitor) };
+                let constraint =
+                    { <Option<Box<TsType>> as FoldWith<V>>::fold_with(constraint, visitor) };
+                let default = { <Option<Box<TsType>> as FoldWith<V>>::fold_with(default, visitor) };
                 TsTypeParam {
                     span,
                     name,
@@ -135839,89 +106862,45 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParam {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParamDecl {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_param_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_param_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeParamDecl {
+    #[doc = "Calls [Fold`::fold_ts_type_param_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_param_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeParamDecl { span, params } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
-                        self::fields::TsTypeParamDeclField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
-                        self::fields::TsTypeParamDeclField::Params(usize::MAX),
-                    ));
-                    <Vec<TsTypeParam> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let params = { <Vec<TsTypeParam> as FoldWith<V>>::fold_with(params, visitor) };
                 TsTypeParamDecl { span, params }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParamInstantiation {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_param_instantiation`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_param_instantiation(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeParamInstantiation {
+    #[doc = "Calls [Fold`::fold_ts_type_param_instantiation`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_param_instantiation(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeParamInstantiation { span, params } => {
-                let span = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
-                            self::fields::TsTypeParamInstantiationField::Span,
-                        ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let params = {
-                    let mut __ast_path =
-                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
-                            self::fields::TsTypeParamInstantiationField::Params(usize::MAX),
-                        ));
-                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        params,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let params = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(params, visitor) };
                 TsTypeParamInstantiation { span, params }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypePredicate {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_predicate`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_predicate(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypePredicate {
+    #[doc = "Calls [Fold`::fold_ts_type_predicate`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_predicate(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypePredicate {
                 span,
@@ -135929,36 +106908,11 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypePredicate {
                 param_name,
                 type_ann,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
-                        self::fields::TsTypePredicateField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let param_name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
-                        self::fields::TsTypePredicateField::ParamName,
-                    ));
-                    <TsThisTypeOrIdent as FoldWithAstPath<V>>::fold_with_ast_path(
-                        param_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_ann = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
-                        self::fields::TsTypePredicateField::TypeAnn,
-                    ));
-                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_ann,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let param_name =
+                    { <TsThisTypeOrIdent as FoldWith<V>>::fold_with(param_name, visitor) };
+                let type_ann =
+                    { <Option<Box<TsTypeAnn>> as FoldWith<V>>::fold_with(type_ann, visitor) };
                 TsTypePredicate {
                     span,
                     asserts,
@@ -135969,46 +106923,25 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypePredicate {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeQuery {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_query`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_query(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeQuery {
+    #[doc = "Calls [Fold`::fold_ts_type_query`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_query(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeQuery {
                 span,
                 expr_name,
                 type_args,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
-                        self::fields::TsTypeQueryField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let expr_name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
-                        self::fields::TsTypeQueryField::ExprName,
-                    ));
-                    <TsTypeQueryExpr as FoldWithAstPath<V>>::fold_with_ast_path(
-                        expr_name,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let expr_name = { <TsTypeQueryExpr as FoldWith<V>>::fold_with(expr_name, visitor) };
                 let type_args = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
-                        self::fields::TsTypeQueryField::TypeArgs,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_args, visitor,
+                    )
                 };
                 TsTypeQuery {
                     span,
@@ -136019,81 +106952,46 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeQuery {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeQueryExpr {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_query_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_query_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeQueryExpr {
+    #[doc = "Calls [Fold`::fold_ts_type_query_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_query_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeQueryExpr::TsEntityName { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
-                    self::fields::TsTypeQueryExprField::TsEntityName,
-                ));
-                let _field_0 = <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsEntityName as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeQueryExpr::TsEntityName { 0: _field_0 }
             }
             TsTypeQueryExpr::Import { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
-                    self::fields::TsTypeQueryExprField::Import,
-                ));
-                let _field_0 = <TsImportType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsImportType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsTypeQueryExpr::Import { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeRef {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_ref`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_ref(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsTypeRef {
+    #[doc = "Calls [Fold`::fold_ts_type_ref`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_ref(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsTypeRef {
                 span,
                 type_name,
                 type_params,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::TsTypeRef(self::fields::TsTypeRefField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let type_name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
-                        self::fields::TsTypeRefField::TypeName,
-                    ));
-                    <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
-                        type_name,
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let type_name = { <TsEntityName as FoldWith<V>>::fold_with(type_name, visitor) };
+                let type_params = {
+                    <Option<Box<TsTypeParamInstantiation>> as FoldWith<V>>::fold_with(
+                        type_params,
                         visitor,
-                        &mut *__ast_path,
                     )
                 };
-                let type_params = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
-                        self::fields::TsTypeRefField::TypeParams,
-                    ));
-                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_params , visitor , & mut * __ast_path)
-                };
                 TsTypeRef {
                     span,
                     type_name,
@@ -136103,131 +107001,65 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeRef {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsUnionOrIntersectionType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_union_or_intersection_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_union_or_intersection_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsUnionOrIntersectionType {
+    #[doc = "Calls [Fold`::fold_ts_union_or_intersection_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_union_or_intersection_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsUnionOrIntersectionType::TsUnionType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
-                        self::fields::TsUnionOrIntersectionTypeField::TsUnionType,
-                    ));
-                let _field_0 = <TsUnionType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsUnionType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsUnionOrIntersectionType::TsUnionType { 0: _field_0 }
             }
             TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 } => {
-                let mut __ast_path =
-                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
-                        self::fields::TsUnionOrIntersectionTypeField::TsIntersectionType,
-                    ));
-                let _field_0 = <TsIntersectionType as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <TsIntersectionType as FoldWith<V>>::fold_with(_field_0, visitor);
                 TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsUnionType {
-    #[doc = "Calls [FoldAstPath`::fold_ts_union_type`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_union_type(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for TsUnionType {
+    #[doc = "Calls [Fold`::fold_ts_union_type`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_union_type(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             TsUnionType { span, types } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
-                        self::fields::TsUnionTypeField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let types = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
-                        self::fields::TsUnionTypeField::Types(usize::MAX),
-                    ));
-                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        types,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let types = { <Vec<Box<TsType>> as FoldWith<V>>::fold_with(types, visitor) };
                 TsUnionType { span, types }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnaryExpr {
-    #[doc = "Calls [FoldAstPath`::fold_unary_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_unary_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UnaryExpr {
+    #[doc = "Calls [Fold`::fold_unary_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_unary_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UnaryExpr { span, op, arg } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let op = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Op));
-                    <UnaryOp as FoldWithAstPath<V>>::fold_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Arg));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let op = { <UnaryOp as FoldWith<V>>::fold_with(op, visitor) };
+                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
                 UnaryExpr { span, op, arg }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnaryOp {
-    #[doc = "Calls [FoldAstPath`::fold_unary_op`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_unary_op(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UnaryOp {
+    #[doc = "Calls [Fold`::fold_unary_op`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_unary_op(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UnaryOp::Minus => UnaryOp::Minus,
             UnaryOp::Plus => UnaryOp::Plus,
@@ -136239,15 +107071,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnaryOp {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UpdateExpr {
-    #[doc = "Calls [FoldAstPath`::fold_update_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_update_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UpdateExpr {
+    #[doc = "Calls [Fold`::fold_update_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_update_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UpdateExpr {
                 span,
@@ -136255,35 +107085,9 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UpdateExpr {
                 prefix,
                 arg,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
-                        self::fields::UpdateExprField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let op = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UpdateExpr(self::fields::UpdateExprField::Op));
-                    <UpdateOp as FoldWithAstPath<V>>::fold_with_ast_path(
-                        op,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
-                        self::fields::UpdateExprField::Arg,
-                    ));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let op = { <UpdateOp as FoldWith<V>>::fold_with(op, visitor) };
+                let arg = { <Box<Expr> as FoldWith<V>>::fold_with(arg, visitor) };
                 UpdateExpr {
                     span,
                     op,
@@ -136294,55 +107098,34 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UpdateExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UpdateOp {
-    #[doc = "Calls [FoldAstPath`::fold_update_op`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_update_op(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UpdateOp {
+    #[doc = "Calls [Fold`::fold_update_op`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_update_op(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UpdateOp::PlusPlus => UpdateOp::PlusPlus,
             UpdateOp::MinusMinus => UpdateOp::MinusMinus,
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UsingDecl {
-    #[doc = "Calls [FoldAstPath`::fold_using_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_using_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for UsingDecl {
+    #[doc = "Calls [Fold`::fold_using_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_using_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             UsingDecl {
                 span,
                 is_await,
                 decls,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::UsingDecl(self::fields::UsingDeclField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decls = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UsingDecl(
-                        self::fields::UsingDeclField::Decls(usize::MAX),
-                    ));
-                    <Vec<VarDeclarator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decls,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let decls = { <Vec<VarDeclarator> as FoldWith<V>>::fold_with(decls, visitor) };
                 UsingDecl {
                     span,
                     is_await,
@@ -136352,15 +107135,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UsingDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDecl {
-    #[doc = "Calls [FoldAstPath`::fold_var_decl`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_var_decl(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for VarDecl {
+    #[doc = "Calls [Fold`::fold_var_decl`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_var_decl(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             VarDecl {
                 span,
@@ -136369,43 +107150,10 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDecl {
                 declare,
                 decls,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let ctxt = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Ctxt));
-                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
-                        ctxt,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let kind = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Kind));
-                    <VarDeclKind as FoldWithAstPath<V>>::fold_with_ast_path(
-                        kind,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let decls = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDecl(
-                        self::fields::VarDeclField::Decls(usize::MAX),
-                    ));
-                    <Vec<VarDeclarator> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        decls,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let ctxt = { <swc_common::SyntaxContext as FoldWith<V>>::fold_with(ctxt, visitor) };
+                let kind = { <VarDeclKind as FoldWith<V>>::fold_with(kind, visitor) };
+                let decls = { <Vec<VarDeclarator> as FoldWith<V>>::fold_with(decls, visitor) };
                 VarDecl {
                     span,
                     ctxt,
@@ -136417,15 +107165,13 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDecl {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclKind {
-    #[doc = "Calls [FoldAstPath`::fold_var_decl_kind`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_var_decl_kind(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for VarDeclKind {
+    #[doc = "Calls [Fold`::fold_var_decl_kind`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_var_decl_kind(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             VarDeclKind::Var => VarDeclKind::Var,
             VarDeclKind::Let => VarDeclKind::Let,
@@ -136433,83 +107179,42 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclKind {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclOrExpr {
-    #[doc = "Calls [FoldAstPath`::fold_var_decl_or_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_var_decl_or_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for VarDeclOrExpr {
+    #[doc = "Calls [Fold`::fold_var_decl_or_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_var_decl_or_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             VarDeclOrExpr::VarDecl { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
-                    self::fields::VarDeclOrExprField::VarDecl,
-                ));
-                let _field_0 = <Box<VarDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
+                let _field_0 = <Box<VarDecl> as FoldWith<V>>::fold_with(_field_0, visitor);
                 VarDeclOrExpr::VarDecl { 0: _field_0 }
-            }
-            VarDeclOrExpr::Expr { 0: _field_0 } => {
-                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
-                    self::fields::VarDeclOrExprField::Expr,
-                ));
-                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    _field_0,
-                    visitor,
-                    &mut *__ast_path,
-                );
-                VarDeclOrExpr::Expr { 0: _field_0 }
-            }
-        }
-    }
-}
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclarator {
-    #[doc = "Calls [FoldAstPath`::fold_var_declarator`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_var_declarator(visitor, self, __ast_path)
-    }
-
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        match self {
-            VarDeclarator {
-                span,
-                name,
-                init,
-                definite,
-            } => {
-                let span = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
-                        self::fields::VarDeclaratorField::Span,
-                    ));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let name = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
-                        self::fields::VarDeclaratorField::Name,
-                    ));
-                    <Pat as FoldWithAstPath<V>>::fold_with_ast_path(name, visitor, &mut *__ast_path)
-                };
-                let init = {
-                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
-                        self::fields::VarDeclaratorField::Init,
-                    ));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        init,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+            }
+            VarDeclOrExpr::Expr { 0: _field_0 } => {
+                let _field_0 = <Box<Expr> as FoldWith<V>>::fold_with(_field_0, visitor);
+                VarDeclOrExpr::Expr { 0: _field_0 }
+            }
+        }
+    }
+}
+impl<V: ?Sized + Fold> FoldWith<V> for VarDeclarator {
+    #[doc = "Calls [Fold`::fold_var_declarator`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_var_declarator(visitor, self)
+    }
+
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        match self {
+            VarDeclarator {
+                span,
+                name,
+                init,
+                definite,
+            } => {
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let name = { <Pat as FoldWith<V>>::fold_with(name, visitor) };
+                let init = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(init, visitor) };
                 VarDeclarator {
                     span,
                     name,
@@ -136520,125 +107225,55 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclarator {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WhileStmt {
-    #[doc = "Calls [FoldAstPath`::fold_while_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_while_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for WhileStmt {
+    #[doc = "Calls [Fold`::fold_while_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_while_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             WhileStmt { span, test, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let test = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Test));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        test,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Body));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let test = { <Box<Expr> as FoldWith<V>>::fold_with(test, visitor) };
+                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
                 WhileStmt { span, test, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WithStmt {
-    #[doc = "Calls [FoldAstPath`::fold_with_stmt`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_with_stmt(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for WithStmt {
+    #[doc = "Calls [Fold`::fold_with_stmt`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_with_stmt(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             WithStmt { span, obj, body } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let obj = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Obj));
-                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        obj,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let body = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Body));
-                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        body,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let obj = { <Box<Expr> as FoldWith<V>>::fold_with(obj, visitor) };
+                let body = { <Box<Stmt> as FoldWith<V>>::fold_with(body, visitor) };
                 WithStmt { span, obj, body }
             }
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for YieldExpr {
-    #[doc = "Calls [FoldAstPath`::fold_yield_expr`] with `self`."]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_yield_expr(visitor, self, __ast_path)
+impl<V: ?Sized + Fold> FoldWith<V> for YieldExpr {
+    #[doc = "Calls [Fold`::fold_yield_expr`] with `self`."]
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_yield_expr(visitor, self)
     }
 
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         match self {
             YieldExpr {
                 span,
                 arg,
                 delegate,
             } => {
-                let span = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Span));
-                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
-                        span,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
-                let arg = {
-                    let mut __ast_path = __ast_path
-                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Arg));
-                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
-                        arg,
-                        visitor,
-                        &mut *__ast_path,
-                    )
-                };
+                let span = { <swc_common::Span as FoldWith<V>>::fold_with(span, visitor) };
+                let arg = { <Option<Box<Expr>> as FoldWith<V>>::fold_with(arg, visitor) };
                 YieldExpr {
                     span,
                     arg,
@@ -136648,10995 +107283,15671 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for YieldExpr {
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
-    #[doc = "Calls [FoldAstPath`::fold_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
+    #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_atom(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BigIntValue {
-    #[doc = "Calls [FoldAstPath`::fold_big_int_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for BigIntValue {
+    #[doc = "Calls [Fold`::fold_big_int_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_big_int_value(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_big_int_value(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ClassMember> {
-    #[doc = "Calls [FoldAstPath`::fold_class_members`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ClassMember> {
+    #[doc = "Calls [Fold`::fold_class_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_class_members(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_class_members(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ClassMember as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ClassMember as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Decorator> {
-    #[doc = "Calls [FoldAstPath`::fold_decorators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Decorator> {
+    #[doc = "Calls [Fold`::fold_decorators`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_decorators(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_decorators(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Decorator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Decorator as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ExportSpecifier> {
-    #[doc = "Calls [FoldAstPath`::fold_export_specifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExportSpecifier> {
+    #[doc = "Calls [Fold`::fold_export_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_export_specifiers(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_export_specifiers(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ExportSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ExportSpecifier as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ExprOrSpread> {
-    #[doc = "Calls [FoldAstPath`::fold_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExprOrSpread> {
+    #[doc = "Calls [Fold`::fold_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_expr_or_spreads(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ExprOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ExprOrSpread as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Box<Expr>> {
-    #[doc = "Calls [FoldAstPath`::fold_exprs`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<Expr>> {
+    #[doc = "Calls [Fold`::fold_exprs`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_exprs(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_exprs(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Box<Expr> as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ImportSpecifier> {
-    #[doc = "Calls [FoldAstPath`::fold_import_specifiers`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportSpecifier> {
+    #[doc = "Calls [Fold`::fold_import_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_specifiers(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_specifiers(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ImportSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ImportSpecifier as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ImportWithItem> {
-    #[doc = "Calls [FoldAstPath`::fold_import_with_items`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportWithItem> {
+    #[doc = "Calls [Fold`::fold_import_with_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_import_with_items(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_import_with_items(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ImportWithItem as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ImportWithItem as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<JSXAttrOrSpread> {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<JSXAttrOrSpread> {
+    #[doc = "Calls [Fold`::fold_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_attr_or_spreads(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_attr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <JSXAttrOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <JSXAttrOrSpread as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<JSXElementChild> {
-    #[doc = "Calls [FoldAstPath`::fold_jsx_element_childs`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<JSXElementChild> {
+    #[doc = "Calls [Fold`::fold_jsx_element_childs`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_jsx_element_childs(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_jsx_element_childs(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <JSXElementChild as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <JSXElementChild as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ModuleItem> {
-    #[doc = "Calls [FoldAstPath`::fold_module_items`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ModuleItem> {
+    #[doc = "Calls [Fold`::fold_module_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_module_items(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_module_items(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ModuleItem as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ModuleItem as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ObjectPatProp> {
-    #[doc = "Calls [FoldAstPath`::fold_object_pat_props`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ObjectPatProp> {
+    #[doc = "Calls [Fold`::fold_object_pat_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_object_pat_props(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_object_pat_props(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ObjectPatProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ObjectPatProp as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Accessibility> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_accessibility`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Accessibility> {
+    #[doc = "Calls [Fold`::fold_opt_accessibility`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_accessibility(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_accessibility(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Accessibility as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Accessibility as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_atom`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [Fold`::fold_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_atom(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_atom(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<BlockStmt> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_block_stmt`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<BlockStmt> {
+    #[doc = "Calls [Fold`::fold_opt_block_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_block_stmt(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_block_stmt(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <BlockStmt as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<CatchClause> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_catch_clause`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<CatchClause> {
+    #[doc = "Calls [Fold`::fold_opt_catch_clause`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_catch_clause(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_catch_clause(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <CatchClause as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <CatchClause as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Expr>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_expr`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Expr>> {
+    #[doc = "Calls [Fold`::fold_opt_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_expr(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_expr(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<Expr> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ExprOrSpread> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_expr_or_spread`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<ExprOrSpread> {
+    #[doc = "Calls [Fold`::fold_opt_expr_or_spread`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_expr_or_spread(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_expr_or_spread(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <ExprOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <ExprOrSpread as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<ExprOrSpread>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<ExprOrSpread>> {
+    #[doc = "Calls [Fold`::fold_opt_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_expr_or_spreads(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Vec<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Vec<ExprOrSpread> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Ident> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ident`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Ident> {
+    #[doc = "Calls [Fold`::fold_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ident(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ident(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Ident as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Ident as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<JSXAttrValue> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_jsx_attr_value`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<JSXAttrValue> {
+    #[doc = "Calls [Fold`::fold_opt_jsx_attr_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_jsx_attr_value(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_jsx_attr_value(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <JSXAttrValue as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <JSXAttrValue as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<JSXClosingElement> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_jsx_closing_element`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<JSXClosingElement> {
+    #[doc = "Calls [Fold`::fold_opt_jsx_closing_element`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_jsx_closing_element(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_jsx_closing_element(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <JSXClosingElement as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <JSXClosingElement as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ModuleExportName> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_module_export_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<ModuleExportName> {
+    #[doc = "Calls [Fold`::fold_opt_module_export_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_module_export_name(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_module_export_name(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <ModuleExportName as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <ModuleExportName as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ObjectLit>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_object_lit`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<ObjectLit>> {
+    #[doc = "Calls [Fold`::fold_opt_object_lit`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_object_lit(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_object_lit(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<ObjectLit> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<ObjectLit> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Pat> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_pat`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Pat> {
+    #[doc = "Calls [Fold`::fold_opt_pat`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_pat(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_pat(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Pat as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Pat as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_common::Span> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_span`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<swc_common::Span> {
+    #[doc = "Calls [Fold`::fold_opt_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_span(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_span(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <swc_common::Span as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Stmt>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_stmt`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Stmt>> {
+    #[doc = "Calls [Fold`::fold_opt_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_stmt(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_stmt(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<Stmt> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Str>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_str`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Str>> {
+    #[doc = "Calls [Fold`::fold_opt_str`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_str(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_str(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<Str> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TruePlusMinus> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_true_plus_minus`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<TruePlusMinus> {
+    #[doc = "Calls [Fold`::fold_opt_true_plus_minus`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_true_plus_minus(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_true_plus_minus(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <TruePlusMinus as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <TruePlusMinus as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TsEntityName> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ts_entity_name`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<TsEntityName> {
+    #[doc = "Calls [Fold`::fold_opt_ts_entity_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ts_entity_name(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ts_entity_name(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <TsEntityName as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TsNamespaceBody> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ts_namespace_body`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<TsNamespaceBody> {
+    #[doc = "Calls [Fold`::fold_opt_ts_namespace_body`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ts_namespace_body(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ts_namespace_body(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <TsNamespaceBody as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <TsNamespaceBody as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsType>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsType>> {
+    #[doc = "Calls [Fold`::fold_opt_ts_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ts_type(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ts_type(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<TsType> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeAnn>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type_ann`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsTypeAnn>> {
+    #[doc = "Calls [Fold`::fold_opt_ts_type_ann`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ts_type_ann(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ts_type_ann(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<TsTypeAnn> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<TsTypeAnn> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeParamDecl>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsTypeParamDecl>> {
+    #[doc = "Calls [Fold`::fold_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ts_type_param_decl(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ts_type_param_decl(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<TsTypeParamDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<TsTypeParamDecl> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeParamInstantiation>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<TsTypeParamInstantiation>> {
+    #[doc = "Calls [Fold`::fold_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_ts_type_param_instantiation(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <Box<TsTypeParamInstantiation> as FoldWithAstPath<V>>::fold_with_ast_path(
-                inner, visitor, __ast_path,
-            )
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <Box<TsTypeParamInstantiation> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<VarDeclOrExpr> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Option<VarDeclOrExpr> {
+    #[doc = "Calls [Fold`::fold_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_var_decl_or_expr(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_var_decl_or_expr(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.map(|inner| {
-            <VarDeclOrExpr as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        self.map(|inner| <VarDeclOrExpr as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Option<ExprOrSpread>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Option<ExprOrSpread>> {
+    #[doc = "Calls [Fold`::fold_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_vec_expr_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Option<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Option<ExprOrSpread> as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Option<Pat>> {
-    #[doc = "Calls [FoldAstPath`::fold_opt_vec_pats`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Option<Pat>> {
+    #[doc = "Calls [Fold`::fold_opt_vec_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_opt_vec_pats(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_opt_vec_pats(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Option<Pat> as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ParamOrTsParamProp> {
-    #[doc = "Calls [FoldAstPath`::fold_param_or_ts_param_props`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<ParamOrTsParamProp> {
+    #[doc = "Calls [Fold`::fold_param_or_ts_param_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_param_or_ts_param_props(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_param_or_ts_param_props(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <ParamOrTsParamProp as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <ParamOrTsParamProp as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Param> {
-    #[doc = "Calls [FoldAstPath`::fold_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Param> {
+    #[doc = "Calls [Fold`::fold_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_params(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_params(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Param as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Param as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Pat> {
-    #[doc = "Calls [FoldAstPath`::fold_pats`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Pat> {
+    #[doc = "Calls [Fold`::fold_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_pats(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_pats(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Pat as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Pat as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PropOrSpread> {
-    #[doc = "Calls [FoldAstPath`::fold_prop_or_spreads`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<PropOrSpread> {
+    #[doc = "Calls [Fold`::fold_prop_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_prop_or_spreads(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_prop_or_spreads(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <PropOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <PropOrSpread as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::Span {
-    #[doc = "Calls [FoldAstPath`::fold_span`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
+    #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_span(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Stmt> {
-    #[doc = "Calls [FoldAstPath`::fold_stmts`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Stmt> {
+    #[doc = "Calls [Fold`::fold_stmts`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_stmts(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_stmts(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Stmt as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Stmt as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SwitchCase> {
-    #[doc = "Calls [FoldAstPath`::fold_switch_cases`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<SwitchCase> {
+    #[doc = "Calls [Fold`::fold_switch_cases`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_switch_cases(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_switch_cases(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <SwitchCase as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <SwitchCase as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::SyntaxContext {
-    #[doc = "Calls [FoldAstPath`::fold_syntax_context`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for swc_common::SyntaxContext {
+    #[doc = "Calls [Fold`::fold_syntax_context`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_syntax_context(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_syntax_context(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TplElement> {
-    #[doc = "Calls [FoldAstPath`::fold_tpl_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<TplElement> {
+    #[doc = "Calls [Fold`::fold_tpl_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_tpl_elements(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_tpl_elements(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <TplElement as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <TplElement as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsEnumMember> {
-    #[doc = "Calls [FoldAstPath`::fold_ts_enum_members`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsEnumMember> {
+    #[doc = "Calls [Fold`::fold_ts_enum_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_enum_members(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_enum_members(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <TsEnumMember as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <TsEnumMember as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsExprWithTypeArgs> {
-    #[doc = "Calls [FoldAstPath`::fold_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsExprWithTypeArgs> {
+    #[doc = "Calls [Fold`::fold_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_expr_with_type_argss(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_expr_with_type_argss(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <TsExprWithTypeArgs as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <TsExprWithTypeArgs as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsFnParam> {
-    #[doc = "Calls [FoldAstPath`::fold_ts_fn_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsFnParam> {
+    #[doc = "Calls [Fold`::fold_ts_fn_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_fn_params(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_fn_params(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <TsFnParam as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <TsFnParam as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTupleElement> {
-    #[doc = "Calls [FoldAstPath`::fold_ts_tuple_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTupleElement> {
+    #[doc = "Calls [Fold`::fold_ts_tuple_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_tuple_elements(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_tuple_elements(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <TsTupleElement as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <TsTupleElement as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTypeElement> {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_elements`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeElement> {
+    #[doc = "Calls [Fold`::fold_ts_type_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_elements(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_elements(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <TsTypeElement as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <TsTypeElement as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTypeParam> {
-    #[doc = "Calls [FoldAstPath`::fold_ts_type_params`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeParam> {
+    #[doc = "Calls [Fold`::fold_ts_type_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_type_params(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_type_params(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <TsTypeParam as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <TsTypeParam as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Box<TsType>> {
-    #[doc = "Calls [FoldAstPath`::fold_ts_types`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<TsType>> {
+    #[doc = "Calls [Fold`::fold_ts_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_ts_types(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_ts_types(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <Box<TsType> as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<VarDeclarator> {
-    #[doc = "Calls [FoldAstPath`::fold_var_declarators`] with `self`. (Extra impl)"]
+impl<V: ?Sized + Fold> FoldWith<V> for Vec<VarDeclarator> {
+    #[doc = "Calls [Fold`::fold_var_declarators`] with `self`. (Extra impl)"]
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        <V as FoldAstPath>::fold_var_declarators(visitor, self, __ast_path)
+    fn fold_with(self, visitor: &mut V) -> Self {
+        <V as Fold>::fold_var_declarators(visitor, self)
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        self.into_iter()
-            .enumerate()
-            .map(|(__idx, item)| {
-                let mut __ast_path = __ast_path.with_index_guard(__idx);
-                <VarDeclarator as FoldWithAstPath<V>>::fold_with_ast_path(
-                    item,
-                    visitor,
-                    &mut *__ast_path,
-                )
-            })
-            .collect()
+    fn fold_children_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::move_map::MoveMap::move_map(self, |item| {
+            <VarDeclarator as FoldWith<V>>::fold_with(item, visitor)
+        })
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V, T> FoldWithAstPath<V> for std::boxed::Box<T>
+impl<V, T> FoldWith<V> for std::boxed::Box<T>
 where
-    V: ?Sized + FoldAstPath,
-    T: FoldWithAstPath<V>,
+    V: ?Sized + Fold,
+    T: FoldWith<V>,
 {
     #[inline]
-    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
-        swc_visit::util::map::Map::map(self, |inner| {
-            <T as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
-        })
+    fn fold_with(self, visitor: &mut V) -> Self {
+        swc_visit::util::map::Map::map(self, |inner| <T as FoldWith<V>>::fold_with(inner, visitor))
     }
 
     #[inline]
-    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+    fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::map::Map::map(self, |inner| {
-            <T as FoldWithAstPath<V>>::fold_children_with_ast_path(inner, visitor, __ast_path)
+            <T as FoldWith<V>>::fold_children_with(inner, visitor)
         })
     }
 }
 #[doc = r" A visitor trait for traversing the AST."]
-pub trait VisitAll {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait FoldAstPath {
     #[doc = "Visit a node of type `Accessibility`.\n\nBy default, this method calls \
-             [`Accessibility::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Accessibility::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_accessibility(&mut self, node: &Accessibility) {
-        <Accessibility as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_accessibility(
+        &mut self,
+        node: Accessibility,
+        __ast_path: &mut AstKindPath,
+    ) -> Accessibility {
+        <Accessibility as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ArrayLit`.\n\nBy default, this method calls \
-             [`ArrayLit::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ArrayLit::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_array_lit(&mut self, node: &ArrayLit) {
-        <ArrayLit as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
+        <ArrayLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ArrayPat`.\n\nBy default, this method calls \
-             [`ArrayPat::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ArrayPat::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_array_pat(&mut self, node: &ArrayPat) {
-        <ArrayPat as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
+        <ArrayPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ArrowExpr`.\n\nBy default, this method calls \
-             [`ArrowExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ArrowExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
-        <ArrowExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
+        <ArrowExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignExpr`.\n\nBy default, this method calls \
-             [`AssignExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AssignExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_assign_expr(&mut self, node: &AssignExpr) {
-        <AssignExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
+        <AssignExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignOp`.\n\nBy default, this method calls \
-             [`AssignOp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AssignOp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_assign_op(&mut self, node: &AssignOp) {
-        <AssignOp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
+        <AssignOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignPat`.\n\nBy default, this method calls \
-             [`AssignPat::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AssignPat::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_assign_pat(&mut self, node: &AssignPat) {
-        <AssignPat as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
+        <AssignPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignPatProp`.\n\nBy default, this method calls \
-             [`AssignPatProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AssignPatProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
-        <AssignPatProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_assign_pat_prop(
+        &mut self,
+        node: AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignPatProp {
+        <AssignPatProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AssignProp`.\n\nBy default, this method calls \
-             [`AssignProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AssignProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_assign_prop(&mut self, node: &AssignProp) {
-        <AssignProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
+        <AssignProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignTarget`.\n\nBy default, this method calls \
-             [`AssignTarget::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AssignTarget::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_assign_target(&mut self, node: &AssignTarget) {
-        <AssignTarget as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_assign_target(
+        &mut self,
+        node: AssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTarget {
+        <AssignTarget as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AssignTargetPat`.\n\nBy default, this method calls \
-             [`AssignTargetPat::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`AssignTargetPat::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
-        <AssignTargetPat as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_assign_target_pat(
+        &mut self,
+        node: AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTargetPat {
+        <AssignTargetPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`swc_atoms :: Atom::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <swc_atoms::Atom as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
+        <swc_atoms::Atom as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `AutoAccessor`.\n\nBy default, this method calls \
-             [`AutoAccessor::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AutoAccessor::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
-        <AutoAccessor as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_auto_accessor(
+        &mut self,
+        node: AutoAccessor,
+        __ast_path: &mut AstKindPath,
+    ) -> AutoAccessor {
+        <AutoAccessor as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AwaitExpr`.\n\nBy default, this method calls \
-             [`AwaitExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`AwaitExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_await_expr(&mut self, node: &AwaitExpr) {
-        <AwaitExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
+        <AwaitExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BigInt`.\n\nBy default, this method calls \
-             [`BigInt::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`BigInt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_big_int(&mut self, node: &BigInt) {
-        <BigInt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
+        <BigInt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BigIntValue`.\n\nBy default, this method calls \
-             [`BigIntValue::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`BigIntValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_big_int_value(&mut self, node: &BigIntValue) {
-        <BigIntValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_big_int_value(
+        &mut self,
+        node: BigIntValue,
+        __ast_path: &mut AstKindPath,
+    ) -> BigIntValue {
+        <BigIntValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BinExpr`.\n\nBy default, this method calls \
-             [`BinExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`BinExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_bin_expr(&mut self, node: &BinExpr) {
-        <BinExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
+        <BinExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BinaryOp`.\n\nBy default, this method calls \
-             [`BinaryOp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`BinaryOp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_binary_op(&mut self, node: &BinaryOp) {
-        <BinaryOp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
+        <BinaryOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BindingIdent`.\n\nBy default, this method calls \
-             [`BindingIdent::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`BindingIdent::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_binding_ident(&mut self, node: &BindingIdent) {
-        <BindingIdent as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_binding_ident(
+        &mut self,
+        node: BindingIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> BindingIdent {
+        <BindingIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BlockStmt`.\n\nBy default, this method calls \
-             [`BlockStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`BlockStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_block_stmt(&mut self, node: &BlockStmt) {
-        <BlockStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
+        <BlockStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BlockStmtOrExpr`.\n\nBy default, this method calls \
-             [`BlockStmtOrExpr::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`BlockStmtOrExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
-        <BlockStmtOrExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_block_stmt_or_expr(
+        &mut self,
+        node: BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> BlockStmtOrExpr {
+        <BlockStmtOrExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Bool`.\n\nBy default, this method calls \
-             [`Bool::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Bool::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_bool(&mut self, node: &Bool) {
-        <Bool as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
+        <Bool as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `BreakStmt`.\n\nBy default, this method calls \
-             [`BreakStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`BreakStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_break_stmt(&mut self, node: &BreakStmt) {
-        <BreakStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
+        <BreakStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CallExpr`.\n\nBy default, this method calls \
-             [`CallExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CallExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_call_expr(&mut self, node: &CallExpr) {
-        <CallExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
+        <CallExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Callee`.\n\nBy default, this method calls \
-             [`Callee::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Callee::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_callee(&mut self, node: &Callee) {
-        <Callee as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
+        <Callee as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `CatchClause`.\n\nBy default, this method calls \
-             [`CatchClause::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CatchClause::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_catch_clause(&mut self, node: &CatchClause) {
-        <CatchClause as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_catch_clause(
+        &mut self,
+        node: CatchClause,
+        __ast_path: &mut AstKindPath,
+    ) -> CatchClause {
+        <CatchClause as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Class`.\n\nBy default, this method calls \
-             [`Class::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Class::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_class(&mut self, node: &Class) {
-        <Class as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
+        <Class as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ClassDecl`.\n\nBy default, this method calls \
-             [`ClassDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ClassDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_class_decl(&mut self, node: &ClassDecl) {
-        <ClassDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
+        <ClassDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ClassExpr`.\n\nBy default, this method calls \
-             [`ClassExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ClassExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_class_expr(&mut self, node: &ClassExpr) {
-        <ClassExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
+        <ClassExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ClassMember`.\n\nBy default, this method calls \
-             [`ClassMember::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ClassMember::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_class_member(&mut self, node: &ClassMember) {
-        <ClassMember as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class_member(
+        &mut self,
+        node: ClassMember,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMember {
+        <ClassMember as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < ClassMember >`.\n\nBy default, this method calls [`Vec < \
-             ClassMember >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             ClassMember >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_class_members(&mut self, node: &[ClassMember]) {
-        <[ClassMember] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class_members(
+        &mut self,
+        node: Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ClassMember> {
+        <Vec<ClassMember> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ClassMethod`.\n\nBy default, this method calls \
-             [`ClassMethod::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ClassMethod::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_class_method(&mut self, node: &ClassMethod) {
-        <ClassMethod as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class_method(
+        &mut self,
+        node: ClassMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMethod {
+        <ClassMethod as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ClassProp`.\n\nBy default, this method calls \
-             [`ClassProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ClassProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_class_prop(&mut self, node: &ClassProp) {
-        <ClassProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
+        <ClassProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ComputedPropName`.\n\nBy default, this method calls \
-             [`ComputedPropName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ComputedPropName::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
-        <ComputedPropName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_computed_prop_name(
+        &mut self,
+        node: ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) -> ComputedPropName {
+        <ComputedPropName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `CondExpr`.\n\nBy default, this method calls \
-             [`CondExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`CondExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_cond_expr(&mut self, node: &CondExpr) {
-        <CondExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
+        <CondExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Constructor`.\n\nBy default, this method calls \
-             [`Constructor::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Constructor::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_constructor(&mut self, node: &Constructor) {
-        <Constructor as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
+        <Constructor as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ContinueStmt`.\n\nBy default, this method calls \
-             [`ContinueStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ContinueStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
-        <ContinueStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_continue_stmt(
+        &mut self,
+        node: ContinueStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> ContinueStmt {
+        <ContinueStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `DebuggerStmt`.\n\nBy default, this method calls \
-             [`DebuggerStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`DebuggerStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
-        <DebuggerStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_debugger_stmt(
+        &mut self,
+        node: DebuggerStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DebuggerStmt {
+        <DebuggerStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Decl`.\n\nBy default, this method calls \
-             [`Decl::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Decl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_decl(&mut self, node: &Decl) {
-        <Decl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
+        <Decl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Decorator`.\n\nBy default, this method calls \
-             [`Decorator::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Decorator::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_decorator(&mut self, node: &Decorator) {
-        <Decorator as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
+        <Decorator as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Decorator >`.\n\nBy default, this method calls [`Vec < \
-             Decorator >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             Decorator >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_decorators(&mut self, node: &[Decorator]) {
-        <[Decorator] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_decorators(
+        &mut self,
+        node: Vec<Decorator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Decorator> {
+        <Vec<Decorator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `DefaultDecl`.\n\nBy default, this method calls \
-             [`DefaultDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`DefaultDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_default_decl(&mut self, node: &DefaultDecl) {
-        <DefaultDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_default_decl(
+        &mut self,
+        node: DefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> DefaultDecl {
+        <DefaultDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `DoWhileStmt`.\n\nBy default, this method calls \
-             [`DoWhileStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`DoWhileStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
-        <DoWhileStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_do_while_stmt(
+        &mut self,
+        node: DoWhileStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DoWhileStmt {
+        <DoWhileStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `EmptyStmt`.\n\nBy default, this method calls \
-             [`EmptyStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`EmptyStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
-        <EmptyStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
+        <EmptyStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `EsVersion`.\n\nBy default, this method calls \
-             [`EsVersion::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`EsVersion::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_es_version(&mut self, node: &EsVersion) {
-        <EsVersion as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
+        <EsVersion as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExportAll`.\n\nBy default, this method calls \
-             [`ExportAll::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportAll::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_export_all(&mut self, node: &ExportAll) {
-        <ExportAll as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
+        <ExportAll as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExportDecl`.\n\nBy default, this method calls \
-             [`ExportDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_export_decl(&mut self, node: &ExportDecl) {
-        <ExportDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
+        <ExportDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExportDefaultDecl`.\n\nBy default, this method calls \
-             [`ExportDefaultDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportDefaultDecl::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
-        <ExportDefaultDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_default_decl(
+        &mut self,
+        node: ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultDecl {
+        <ExportDefaultDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDefaultExpr`.\n\nBy default, this method calls \
-             [`ExportDefaultExpr::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportDefaultExpr::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
-        <ExportDefaultExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_default_expr(
+        &mut self,
+        node: ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultExpr {
+        <ExportDefaultExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ExportDefaultSpecifier::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportDefaultSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
-        <ExportDefaultSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_default_specifier(
+        &mut self,
+        node: ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultSpecifier {
+        <ExportDefaultSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamedSpecifier::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportNamedSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
-        <ExportNamedSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_named_specifier(
+        &mut self,
+        node: ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamedSpecifier {
+        <ExportNamedSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportNamespaceSpecifier`.\n\nBy default, this method calls \
-             [`ExportNamespaceSpecifier::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportNamespaceSpecifier::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
-        <ExportNamespaceSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_namespace_specifier(
+        &mut self,
+        node: ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamespaceSpecifier {
+        <ExportNamespaceSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExportSpecifier`.\n\nBy default, this method calls \
-             [`ExportSpecifier::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ExportSpecifier::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
-        <ExportSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_specifier(
+        &mut self,
+        node: ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportSpecifier {
+        <ExportSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ExportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ExportSpecifier >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < ExportSpecifier >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
-        <[ExportSpecifier] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_export_specifiers(
+        &mut self,
+        node: Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExportSpecifier> {
+        <Vec<ExportSpecifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Expr`.\n\nBy default, this method calls \
-             [`Expr::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Expr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_expr(&mut self, node: &Expr) {
-        <Expr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
+        <Expr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ExprOrSpread`.\n\nBy default, this method calls \
-             [`ExprOrSpread::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ExprOrSpread::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
-        <ExprOrSpread as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_expr_or_spread(
+        &mut self,
+        node: ExprOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> ExprOrSpread {
+        <ExprOrSpread as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < ExprOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             ExprOrSpread >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             ExprOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
-        <[ExprOrSpread] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_expr_or_spreads(
+        &mut self,
+        node: Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExprOrSpread> {
+        <Vec<ExprOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ExprStmt`.\n\nBy default, this method calls \
-             [`ExprStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ExprStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_expr_stmt(&mut self, node: &ExprStmt) {
-        <ExprStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
+        <ExprStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Box < Expr > >`.\n\nBy default, this method calls [`Vec < \
-             Box < Expr > >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             Box < Expr > >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_exprs(&mut self, node: &[Box<Expr>]) {
-        <[Box<Expr>] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
+        <Vec<Box<Expr>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `FnDecl`.\n\nBy default, this method calls \
-             [`FnDecl::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`FnDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_fn_decl(&mut self, node: &FnDecl) {
-        <FnDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
+        <FnDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `FnExpr`.\n\nBy default, this method calls \
-             [`FnExpr::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`FnExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_fn_expr(&mut self, node: &FnExpr) {
-        <FnExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
+        <FnExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForHead`.\n\nBy default, this method calls \
-             [`ForHead::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ForHead::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_for_head(&mut self, node: &ForHead) {
-        <ForHead as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
+        <ForHead as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForInStmt`.\n\nBy default, this method calls \
-             [`ForInStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ForInStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
-        <ForInStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
+        <ForInStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForOfStmt`.\n\nBy default, this method calls \
-             [`ForOfStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ForOfStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
-        <ForOfStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
+        <ForOfStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ForStmt`.\n\nBy default, this method calls \
-             [`ForStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ForStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_for_stmt(&mut self, node: &ForStmt) {
-        <ForStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
+        <ForStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
-             [`Function::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Function::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <Function as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+        <Function as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `GetterProp`.\n\nBy default, this method calls \
-             [`GetterProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`GetterProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_getter_prop(&mut self, node: &GetterProp) {
-        <GetterProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
+        <GetterProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
-             [`Ident::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Ident::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <Ident as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+        <Ident as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `IdentName`.\n\nBy default, this method calls \
-             [`IdentName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`IdentName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ident_name(&mut self, node: &IdentName) {
-        <IdentName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
+        <IdentName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `IfStmt`.\n\nBy default, this method calls \
-             [`IfStmt::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`IfStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_if_stmt(&mut self, node: &IfStmt) {
-        <IfStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
+        <IfStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Import`.\n\nBy default, this method calls \
-             [`Import::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Import::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_import(&mut self, node: &Import) {
-        <Import as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
+        <Import as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportDecl`.\n\nBy default, this method calls \
-             [`ImportDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_import_decl(&mut self, node: &ImportDecl) {
-        <ImportDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
+        <ImportDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportDefaultSpecifier`.\n\nBy default, this method calls \
-             [`ImportDefaultSpecifier::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportDefaultSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
-        <ImportDefaultSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_default_specifier(
+        &mut self,
+        node: ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportDefaultSpecifier {
+        <ImportDefaultSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportNamedSpecifier`.\n\nBy default, this method calls \
-             [`ImportNamedSpecifier::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportNamedSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
-        <ImportNamedSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_named_specifier(
+        &mut self,
+        node: ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportNamedSpecifier {
+        <ImportNamedSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportPhase`.\n\nBy default, this method calls \
-             [`ImportPhase::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportPhase::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_import_phase(&mut self, node: &ImportPhase) {
-        <ImportPhase as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_phase(
+        &mut self,
+        node: ImportPhase,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPhase {
+        <ImportPhase as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportSpecifier`.\n\nBy default, this method calls \
-             [`ImportSpecifier::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportSpecifier::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
-        <ImportSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_specifier(
+        &mut self,
+        node: ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportSpecifier {
+        <ImportSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ImportSpecifier >`.\n\nBy default, this method calls \
-             [`Vec < ImportSpecifier >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < ImportSpecifier >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
-        <[ImportSpecifier] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_specifiers(
+        &mut self,
+        node: Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportSpecifier> {
+        <Vec<ImportSpecifier> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportStarAsSpecifier`.\n\nBy default, this method calls \
-             [`ImportStarAsSpecifier::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportStarAsSpecifier::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
-        <ImportStarAsSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_star_as_specifier(
+        &mut self,
+        node: ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportStarAsSpecifier {
+        <ImportStarAsSpecifier as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ImportWith`.\n\nBy default, this method calls \
-             [`ImportWith::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportWith::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_import_with(&mut self, node: &ImportWith) {
-        <ImportWith as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
+        <ImportWith as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
-             [`ImportWithItem::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ImportWithItem::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_import_with_item(&mut self, node: &ImportWithItem) {
-        <ImportWithItem as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_with_item(
+        &mut self,
+        node: ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportWithItem {
+        <ImportWithItem as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ImportWithItem >`.\n\nBy default, this method calls [`Vec \
-             < ImportWithItem >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < ImportWithItem >::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
-        <[ImportWithItem] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_import_with_items(
+        &mut self,
+        node: Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportWithItem> {
+        <Vec<ImportWithItem> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Invalid`.\n\nBy default, this method calls \
-             [`Invalid::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Invalid::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_invalid(&mut self, node: &Invalid) {
-        <Invalid as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
+        <Invalid as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXAttr`.\n\nBy default, this method calls \
-             [`JSXAttr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXAttr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_jsx_attr(&mut self, node: &JSXAttr) {
-        <JSXAttr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
+        <JSXAttr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXAttrName`.\n\nBy default, this method calls \
-             [`JSXAttrName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXAttrName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
-        <JSXAttrName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_attr_name(
+        &mut self,
+        node: JSXAttrName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrName {
+        <JSXAttrName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXAttrOrSpread`.\n\nBy default, this method calls \
-             [`JSXAttrOrSpread::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXAttrOrSpread::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
-        <JSXAttrOrSpread as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_attr_or_spread(
+        &mut self,
+        node: JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrOrSpread {
+        <JSXAttrOrSpread as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < JSXAttrOrSpread >`.\n\nBy default, this method calls \
-             [`Vec < JSXAttrOrSpread >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < JSXAttrOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
-        <[JSXAttrOrSpread] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_attr_or_spreads(
+        &mut self,
+        node: Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXAttrOrSpread> {
+        <Vec<JSXAttrOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXAttrValue`.\n\nBy default, this method calls \
-             [`JSXAttrValue::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXAttrValue::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
-        <JSXAttrValue as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_attr_value(
+        &mut self,
+        node: JSXAttrValue,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrValue {
+        <JSXAttrValue as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXClosingElement`.\n\nBy default, this method calls \
-             [`JSXClosingElement::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXClosingElement::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
-        <JSXClosingElement as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_closing_element(
+        &mut self,
+        node: JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingElement {
+        <JSXClosingElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXClosingFragment`.\n\nBy default, this method calls \
-             [`JSXClosingFragment::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXClosingFragment::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
-        <JSXClosingFragment as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_closing_fragment(
+        &mut self,
+        node: JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingFragment {
+        <JSXClosingFragment as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXElement`.\n\nBy default, this method calls \
-             [`JSXElement::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXElement::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_jsx_element(&mut self, node: &JSXElement) {
-        <JSXElement as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
+        <JSXElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXElementChild`.\n\nBy default, this method calls \
-             [`JSXElementChild::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXElementChild::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
-        <JSXElementChild as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_element_child(
+        &mut self,
+        node: JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementChild {
+        <JSXElementChild as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < JSXElementChild >`.\n\nBy default, this method calls \
-             [`Vec < JSXElementChild >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Vec < JSXElementChild >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
-        <[JSXElementChild] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_element_childs(
+        &mut self,
+        node: Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXElementChild> {
+        <Vec<JSXElementChild> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXElementName`.\n\nBy default, this method calls \
-             [`JSXElementName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXElementName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
-        <JSXElementName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_element_name(
+        &mut self,
+        node: JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementName {
+        <JSXElementName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXEmptyExpr`.\n\nBy default, this method calls \
-             [`JSXEmptyExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXEmptyExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
-        <JSXEmptyExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_empty_expr(
+        &mut self,
+        node: JSXEmptyExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXEmptyExpr {
+        <JSXEmptyExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXExpr`.\n\nBy default, this method calls \
-             [`JSXExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_jsx_expr(&mut self, node: &JSXExpr) {
-        <JSXExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
+        <JSXExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
-             [`JSXExprContainer::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXExprContainer::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
-        <JSXExprContainer as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_expr_container(
+        &mut self,
+        node: JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXExprContainer {
+        <JSXExprContainer as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXFragment`.\n\nBy default, this method calls \
-             [`JSXFragment::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXFragment::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
-        <JSXFragment as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_fragment(
+        &mut self,
+        node: JSXFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXFragment {
+        <JSXFragment as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXMemberExpr`.\n\nBy default, this method calls \
-             [`JSXMemberExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXMemberExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
-        <JSXMemberExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_member_expr(
+        &mut self,
+        node: JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXMemberExpr {
+        <JSXMemberExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXNamespacedName`.\n\nBy default, this method calls \
-             [`JSXNamespacedName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXNamespacedName::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
-        <JSXNamespacedName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_namespaced_name(
+        &mut self,
+        node: JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXNamespacedName {
+        <JSXNamespacedName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXObject`.\n\nBy default, this method calls \
-             [`JSXObject::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXObject::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_jsx_object(&mut self, node: &JSXObject) {
-        <JSXObject as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
+        <JSXObject as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `JSXOpeningElement`.\n\nBy default, this method calls \
-             [`JSXOpeningElement::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXOpeningElement::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
-        <JSXOpeningElement as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_opening_element(
+        &mut self,
+        node: JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningElement {
+        <JSXOpeningElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXOpeningFragment`.\n\nBy default, this method calls \
-             [`JSXOpeningFragment::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXOpeningFragment::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
-        <JSXOpeningFragment as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_opening_fragment(
+        &mut self,
+        node: JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningFragment {
+        <JSXOpeningFragment as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXSpreadChild`.\n\nBy default, this method calls \
-             [`JSXSpreadChild::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXSpreadChild::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
-        <JSXSpreadChild as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_spread_child(
+        &mut self,
+        node: JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXSpreadChild {
+        <JSXSpreadChild as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `JSXText`.\n\nBy default, this method calls \
-             [`JSXText::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`JSXText::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_jsx_text(&mut self, node: &JSXText) {
-        <JSXText as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
+        <JSXText as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Key`.\n\nBy default, this method calls \
-             [`Key::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Key::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_key(&mut self, node: &Key) {
-        <Key as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
+        <Key as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `KeyValuePatProp`.\n\nBy default, this method calls \
-             [`KeyValuePatProp::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`KeyValuePatProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
-        <KeyValuePatProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_key_value_pat_prop(
+        &mut self,
+        node: KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValuePatProp {
+        <KeyValuePatProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `KeyValueProp`.\n\nBy default, this method calls \
-             [`KeyValueProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`KeyValueProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
-        <KeyValueProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_key_value_prop(
+        &mut self,
+        node: KeyValueProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValueProp {
+        <KeyValueProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `LabeledStmt`.\n\nBy default, this method calls \
-             [`LabeledStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`LabeledStmt::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
-        <LabeledStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_labeled_stmt(
+        &mut self,
+        node: LabeledStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> LabeledStmt {
+        <LabeledStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Lit`.\n\nBy default, this method calls \
-             [`Lit::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Lit::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_lit(&mut self, node: &Lit) {
-        <Lit as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
+        <Lit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MemberExpr`.\n\nBy default, this method calls \
-             [`MemberExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MemberExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_member_expr(&mut self, node: &MemberExpr) {
-        <MemberExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
+        <MemberExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MemberProp`.\n\nBy default, this method calls \
-             [`MemberProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MemberProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_member_prop(&mut self, node: &MemberProp) {
-        <MemberProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
+        <MemberProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MetaPropExpr`.\n\nBy default, this method calls \
-             [`MetaPropExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MetaPropExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
-        <MetaPropExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_meta_prop_expr(
+        &mut self,
+        node: MetaPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropExpr {
+        <MetaPropExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MetaPropKind`.\n\nBy default, this method calls \
-             [`MetaPropKind::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MetaPropKind::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
-        <MetaPropKind as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_meta_prop_kind(
+        &mut self,
+        node: MetaPropKind,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropKind {
+        <MetaPropKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MethodKind`.\n\nBy default, this method calls \
-             [`MethodKind::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MethodKind::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_method_kind(&mut self, node: &MethodKind) {
-        <MethodKind as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
+        <MethodKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `MethodProp`.\n\nBy default, this method calls \
-             [`MethodProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`MethodProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_method_prop(&mut self, node: &MethodProp) {
-        <MethodProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
+        <MethodProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Module`.\n\nBy default, this method calls \
-             [`Module::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Module::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_module(&mut self, node: &Module) {
-        <Module as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
+        <Module as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ModuleDecl`.\n\nBy default, this method calls \
-             [`ModuleDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ModuleDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_module_decl(&mut self, node: &ModuleDecl) {
-        <ModuleDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
+        <ModuleDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ModuleExportName`.\n\nBy default, this method calls \
-             [`ModuleExportName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ModuleExportName::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_module_export_name(&mut self, node: &ModuleExportName) {
-        <ModuleExportName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_module_export_name(
+        &mut self,
+        node: ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) -> ModuleExportName {
+        <ModuleExportName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `ModuleItem`.\n\nBy default, this method calls \
-             [`ModuleItem::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ModuleItem::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_module_item(&mut self, node: &ModuleItem) {
-        <ModuleItem as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
+        <ModuleItem as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < ModuleItem >`.\n\nBy default, this method calls [`Vec < \
-             ModuleItem >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             ModuleItem >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_module_items(&mut self, node: &[ModuleItem]) {
-        <[ModuleItem] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_module_items(
+        &mut self,
+        node: Vec<ModuleItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ModuleItem> {
+        <Vec<ModuleItem> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `NamedExport`.\n\nBy default, this method calls \
-             [`NamedExport::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`NamedExport::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_named_export(&mut self, node: &NamedExport) {
-        <NamedExport as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_named_export(
+        &mut self,
+        node: NamedExport,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedExport {
+        <NamedExport as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `NewExpr`.\n\nBy default, this method calls \
-             [`NewExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`NewExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_new_expr(&mut self, node: &NewExpr) {
-        <NewExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
+        <NewExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Null`.\n\nBy default, this method calls \
-             [`Null::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Null::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_null(&mut self, node: &Null) {
-        <Null as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
+        <Null as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
-             [`Number::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Number::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <Number as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+        <Number as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ObjectLit`.\n\nBy default, this method calls \
-             [`ObjectLit::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ObjectLit::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_object_lit(&mut self, node: &ObjectLit) {
-        <ObjectLit as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
+        <ObjectLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ObjectPat`.\n\nBy default, this method calls \
-             [`ObjectPat::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ObjectPat::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_object_pat(&mut self, node: &ObjectPat) {
-        <ObjectPat as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
+        <ObjectPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ObjectPatProp`.\n\nBy default, this method calls \
-             [`ObjectPatProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ObjectPatProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
-        <ObjectPatProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_object_pat_prop(
+        &mut self,
+        node: ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ObjectPatProp {
+        <ObjectPatProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ObjectPatProp >`.\n\nBy default, this method calls [`Vec \
-             < ObjectPatProp >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < ObjectPatProp >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
-        <[ObjectPatProp] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_object_pat_props(
+        &mut self,
+        node: Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ObjectPatProp> {
+        <Vec<ObjectPatProp> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Accessibility >`.\n\nBy default, this method calls \
-             [`Option < Accessibility >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < Accessibility >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
-        <Option<Accessibility> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_accessibility(
+        &mut self,
+        node: Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Accessibility> {
+        <Option<Accessibility> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < swc_atoms :: Atom >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <Option<swc_atoms::Atom> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
+        <Option<swc_atoms::Atom> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < BlockStmt >`.\n\nBy default, this method calls \
-             [`Option < BlockStmt >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < BlockStmt >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>) {
-        <Option<BlockStmt> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_block_stmt(
+        &mut self,
+        node: Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<BlockStmt> {
+        <Option<BlockStmt> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptCall`.\n\nBy default, this method calls \
-             [`OptCall::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`OptCall::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_call(&mut self, node: &OptCall) {
-        <OptCall as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
+        <OptCall as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
-             [`Option < CatchClause >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < CatchClause >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>) {
-        <Option<CatchClause> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_catch_clause(
+        &mut self,
+        node: Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<CatchClause> {
+        <Option<CatchClause> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `OptChainBase`.\n\nBy default, this method calls \
-             [`OptChainBase::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`OptChainBase::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
-        <OptChainBase as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_chain_base(
+        &mut self,
+        node: OptChainBase,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainBase {
+        <OptChainBase as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `OptChainExpr`.\n\nBy default, this method calls \
-             [`OptChainExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`OptChainExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
-        <OptChainExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_chain_expr(
+        &mut self,
+        node: OptChainExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainExpr {
+        <OptChainExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Option < Box < Expr > >`.\n\nBy default, this method calls \
-             [`Option < Box < Expr > >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < Box < Expr > >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>) {
-        <Option<Box<Expr>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_expr(
+        &mut self,
+        node: Option<Box<Expr>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Expr>> {
+        <Option<Box<Expr>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ExprOrSpread >`.\n\nBy default, this method calls \
-             [`Option < ExprOrSpread >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < ExprOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>) {
-        <Option<ExprOrSpread> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_expr_or_spread(
+        &mut self,
+        node: Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ExprOrSpread> {
+        <Option<ExprOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Vec < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Option < Vec < ExprOrSpread > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < Vec < ExprOrSpread > >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>) {
-        <Option<Vec<ExprOrSpread>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_expr_or_spreads(
+        &mut self,
+        node: Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<ExprOrSpread>> {
+        <Option<Vec<ExprOrSpread>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
-             Ident >::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             Ident >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <Option<Ident> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
+        <Option<Ident> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
-             [`Option < JSXAttrValue >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < JSXAttrValue >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>) {
-        <Option<JSXAttrValue> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_jsx_attr_value(
+        &mut self,
+        node: Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXAttrValue> {
+        <Option<JSXAttrValue> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < JSXClosingElement >`.\n\nBy default, this method calls \
-             [`Option < JSXClosingElement >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < JSXClosingElement >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>) {
-        <Option<JSXClosingElement> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_jsx_closing_element(
+        &mut self,
+        node: Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXClosingElement> {
+        <Option<JSXClosingElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < ModuleExportName >`.\n\nBy default, this method calls \
-             [`Option < ModuleExportName >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < ModuleExportName >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_module_export_name(&mut self, node: &Option<ModuleExportName>) {
-        <Option<ModuleExportName> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_module_export_name(
+        &mut self,
+        node: Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ModuleExportName> {
+        <Option<ModuleExportName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < ObjectLit > >`.\n\nBy default, this method calls \
-             [`Option < Box < ObjectLit > >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < Box < ObjectLit > >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_object_lit(&mut self, node: &Option<Box<ObjectLit>>) {
-        <Option<Box<ObjectLit>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_object_lit(
+        &mut self,
+        node: Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ObjectLit>> {
+        <Option<Box<ObjectLit>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Pat >`.\n\nBy default, this method calls [`Option < \
-             Pat >::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             Pat >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_pat(&mut self, node: &Option<Pat>) {
-        <Option<Pat> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
+        <Option<Pat> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Option < swc_common :: Span >`.\n\nBy default, this method \
-             calls [`Option < swc_common :: Span >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < swc_common :: Span >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_span(&mut self, node: &Option<swc_common::Span>) {
-        <Option<swc_common::Span> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_span(
+        &mut self,
+        node: Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_common::Span> {
+        <Option<swc_common::Span> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Stmt > >`.\n\nBy default, this method calls \
-             [`Option < Box < Stmt > >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < Box < Stmt > >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>) {
-        <Option<Box<Stmt>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_stmt(
+        &mut self,
+        node: Option<Box<Stmt>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Stmt>> {
+        <Option<Box<Stmt>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < Str > >`.\n\nBy default, this method calls \
-             [`Option < Box < Str > >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < Box < Str > >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_str(&mut self, node: &Option<Box<Str>>) {
-        <Option<Box<Str>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_str(
+        &mut self,
+        node: Option<Box<Str>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Str>> {
+        <Option<Box<Str>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TruePlusMinus >`.\n\nBy default, this method calls \
-             [`Option < TruePlusMinus >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < TruePlusMinus >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>) {
-        <Option<TruePlusMinus> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_true_plus_minus(
+        &mut self,
+        node: Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TruePlusMinus> {
+        <Option<TruePlusMinus> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TsEntityName >`.\n\nBy default, this method calls \
-             [`Option < TsEntityName >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < TsEntityName >::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>) {
-        <Option<TsEntityName> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_ts_entity_name(
+        &mut self,
+        node: Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsEntityName> {
+        <Option<TsEntityName> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < TsNamespaceBody >`.\n\nBy default, this method calls \
-             [`Option < TsNamespaceBody >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < TsNamespaceBody >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>) {
-        <Option<TsNamespaceBody> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_ts_namespace_body(
+        &mut self,
+        node: Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsNamespaceBody> {
+        <Option<TsNamespaceBody> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsType > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsType > >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < Box < TsType > >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>) {
-        <Option<Box<TsType>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_ts_type(
+        &mut self,
+        node: Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsType>> {
+        <Option<Box<TsType>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeAnn > >`.\n\nBy default, this method calls \
-             [`Option < Box < TsTypeAnn > >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Option < Box < TsTypeAnn > >::fold_children_with_ast_path`]. If you want to \
+             recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>) {
-        <Option<Box<TsTypeAnn>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_ts_type_ann(
+        &mut self,
+        node: Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeAnn>> {
+        <Option<Box<TsTypeAnn>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamDecl > >`.\n\nBy default, this method \
-             calls [`Option < Box < TsTypeParamDecl > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Option < Box < TsTypeParamDecl > >::fold_children_with_ast_path`]. If you \
+             want to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_ts_type_param_decl(&mut self, node: &Option<Box<TsTypeParamDecl>>) {
-        <Option<Box<TsTypeParamDecl>> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_ts_type_param_decl(
+        &mut self,
+        node: Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamDecl>> {
+        <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamInstantiation > >`.\n\nBy default, \
              this method calls [`Option < Box < TsTypeParamInstantiation > \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_opt_ts_type_param_instantiation(
+    fn fold_opt_ts_type_param_instantiation(
         &mut self,
-        node: &Option<Box<TsTypeParamInstantiation>>,
-    ) {
-        <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<Self>>::visit_children_with(
-            node, self,
-        )
+        node: Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamInstantiation>> {
+        < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < Self > > :: fold_children_with_ast_path (node , self , __ast_path)
     }
     #[doc = "Visit a node of type `Option < VarDeclOrExpr >`.\n\nBy default, this method calls \
-             [`Option < VarDeclOrExpr >::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`Option < VarDeclOrExpr >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>) {
-        <Option<VarDeclOrExpr> as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_var_decl_or_expr(
+        &mut self,
+        node: Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<VarDeclOrExpr> {
+        <Option<VarDeclOrExpr> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Option < ExprOrSpread > >`.\n\nBy default, this method \
-             calls [`Vec < Option < ExprOrSpread > >::visit_children_with`]. This method \
-             unconditionally calls the visitor method for all children because it's defined in the \
-             trait [VisitAll]."]
+             calls [`Vec < Option < ExprOrSpread > >::fold_children_with_ast_path`]. If you want \
+             to recurse, you need to call it manually."]
     #[inline]
-    fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>]) {
-        <[Option<ExprOrSpread>] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_vec_expr_or_spreads(
+        &mut self,
+        node: Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<ExprOrSpread>> {
+        <Vec<Option<ExprOrSpread>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Option < Pat > >`.\n\nBy default, this method calls [`Vec \
-             < Option < Pat > >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < Option < Pat > >::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>]) {
-        <[Option<Pat>] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_opt_vec_pats(
+        &mut self,
+        node: Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<Pat>> {
+        <Vec<Option<Pat>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Param`.\n\nBy default, this method calls \
-             [`Param::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Param::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_param(&mut self, node: &Param) {
-        <Param as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
+        <Param as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ParamOrTsParamProp`.\n\nBy default, this method calls \
-             [`ParamOrTsParamProp::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`ParamOrTsParamProp::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp) {
-        <ParamOrTsParamProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_param_or_ts_param_prop(
+        &mut self,
+        node: ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ParamOrTsParamProp {
+        <ParamOrTsParamProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < ParamOrTsParamProp >`.\n\nBy default, this method calls \
-             [`Vec < ParamOrTsParamProp >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Vec < ParamOrTsParamProp >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp]) {
-        <[ParamOrTsParamProp] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_param_or_ts_param_props(
+        &mut self,
+        node: Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ParamOrTsParamProp> {
+        <Vec<ParamOrTsParamProp> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < Param >`.\n\nBy default, this method calls [`Vec < Param \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_params(&mut self, node: &[Param]) {
-        <[Param] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
+        <Vec<Param> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ParenExpr`.\n\nBy default, this method calls \
-             [`ParenExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ParenExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_paren_expr(&mut self, node: &ParenExpr) {
-        <ParenExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
+        <ParenExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Pat`.\n\nBy default, this method calls \
-             [`Pat::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Pat::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_pat(&mut self, node: &Pat) {
-        <Pat as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
+        <Pat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Pat >`.\n\nBy default, this method calls [`Vec < Pat \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_pats(&mut self, node: &[Pat]) {
-        <[Pat] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
+        <Vec<Pat> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PrivateMethod`.\n\nBy default, this method calls \
-             [`PrivateMethod::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`PrivateMethod::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_private_method(&mut self, node: &PrivateMethod) {
-        <PrivateMethod as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_private_method(
+        &mut self,
+        node: PrivateMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateMethod {
+        <PrivateMethod as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `PrivateName`.\n\nBy default, this method calls \
-             [`PrivateName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`PrivateName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_private_name(&mut self, node: &PrivateName) {
-        <PrivateName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_private_name(
+        &mut self,
+        node: PrivateName,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateName {
+        <PrivateName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PrivateProp`.\n\nBy default, this method calls \
-             [`PrivateProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`PrivateProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_private_prop(&mut self, node: &PrivateProp) {
-        <PrivateProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_private_prop(
+        &mut self,
+        node: PrivateProp,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateProp {
+        <PrivateProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Program`.\n\nBy default, this method calls \
-             [`Program::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`Program::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_program(&mut self, node: &Program) {
-        <Program as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
+        <Program as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Prop`.\n\nBy default, this method calls \
-             [`Prop::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Prop::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_prop(&mut self, node: &Prop) {
-        <Prop as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
+        <Prop as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PropName`.\n\nBy default, this method calls \
-             [`PropName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`PropName::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_prop_name(&mut self, node: &PropName) {
-        <PropName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
+        <PropName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `PropOrSpread`.\n\nBy default, this method calls \
-             [`PropOrSpread::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`PropOrSpread::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
-        <PropOrSpread as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_prop_or_spread(
+        &mut self,
+        node: PropOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> PropOrSpread {
+        <PropOrSpread as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
-             PropOrSpread >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             PropOrSpread >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
-        <[PropOrSpread] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_prop_or_spreads(
+        &mut self,
+        node: Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PropOrSpread> {
+        <Vec<PropOrSpread> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
-             [`Regex::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Regex::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_regex(&mut self, node: &Regex) {
-        <Regex as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
+        <Regex as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `RestPat`.\n\nBy default, this method calls \
-             [`RestPat::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`RestPat::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_rest_pat(&mut self, node: &RestPat) {
-        <RestPat as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
+        <RestPat as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ReturnStmt`.\n\nBy default, this method calls \
-             [`ReturnStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ReturnStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_return_stmt(&mut self, node: &ReturnStmt) {
-        <ReturnStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
+        <ReturnStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Script`.\n\nBy default, this method calls \
-             [`Script::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Script::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_script(&mut self, node: &Script) {
-        <Script as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
+        <Script as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SeqExpr`.\n\nBy default, this method calls \
-             [`SeqExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SeqExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_seq_expr(&mut self, node: &SeqExpr) {
-        <SeqExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
+        <SeqExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SetterProp`.\n\nBy default, this method calls \
-             [`SetterProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SetterProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_setter_prop(&mut self, node: &SetterProp) {
-        <SetterProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
+        <SetterProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SimpleAssignTarget`.\n\nBy default, this method calls \
-             [`SimpleAssignTarget::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`SimpleAssignTarget::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
-        <SimpleAssignTarget as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_simple_assign_target(
+        &mut self,
+        node: SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleAssignTarget {
+        <SimpleAssignTarget as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`swc_common :: Span::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <swc_common::Span as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
+        <swc_common::Span as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SpreadElement`.\n\nBy default, this method calls \
-             [`SpreadElement::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SpreadElement::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_spread_element(&mut self, node: &SpreadElement) {
-        <SpreadElement as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_spread_element(
+        &mut self,
+        node: SpreadElement,
+        __ast_path: &mut AstKindPath,
+    ) -> SpreadElement {
+        <SpreadElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `StaticBlock`.\n\nBy default, this method calls \
-             [`StaticBlock::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`StaticBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_static_block(&mut self, node: &StaticBlock) {
-        <StaticBlock as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_static_block(
+        &mut self,
+        node: StaticBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> StaticBlock {
+        <StaticBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Stmt`.\n\nBy default, this method calls \
-             [`Stmt::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Stmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_stmt(&mut self, node: &Stmt) {
-        <Stmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
+        <Stmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Stmt >`.\n\nBy default, this method calls [`Vec < Stmt \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
+             >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_stmts(&mut self, node: &[Stmt]) {
-        <[Stmt] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
+        <Vec<Stmt> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
-             [`Str::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Str::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <Str as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+        <Str as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Super`.\n\nBy default, this method calls \
-             [`Super::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Super::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_super(&mut self, node: &Super) {
-        <Super as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
+        <Super as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SuperProp`.\n\nBy default, this method calls \
-             [`SuperProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SuperProp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_super_prop(&mut self, node: &SuperProp) {
-        <SuperProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
+        <SuperProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `SuperPropExpr`.\n\nBy default, this method calls \
-             [`SuperPropExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SuperPropExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
-        <SuperPropExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_super_prop_expr(
+        &mut self,
+        node: SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> SuperPropExpr {
+        <SuperPropExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SwitchCase`.\n\nBy default, this method calls \
-             [`SwitchCase::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SwitchCase::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_switch_case(&mut self, node: &SwitchCase) {
-        <SwitchCase as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
+        <SwitchCase as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < SwitchCase >`.\n\nBy default, this method calls [`Vec < \
-             SwitchCase >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             SwitchCase >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
-        <[SwitchCase] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_switch_cases(
+        &mut self,
+        node: Vec<SwitchCase>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SwitchCase> {
+        <Vec<SwitchCase> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `SwitchStmt`.\n\nBy default, this method calls \
-             [`SwitchStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`SwitchStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
-        <SwitchStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
+        <SwitchStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `swc_common :: SyntaxContext`.\n\nBy default, this method calls \
-             [`swc_common :: SyntaxContext::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`swc_common :: SyntaxContext::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_syntax_context(&mut self, node: &swc_common::SyntaxContext) {
-        <swc_common::SyntaxContext as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_syntax_context(
+        &mut self,
+        node: swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::SyntaxContext {
+        <swc_common::SyntaxContext as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TaggedTpl`.\n\nBy default, this method calls \
-             [`TaggedTpl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TaggedTpl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
-        <TaggedTpl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
+        <TaggedTpl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ThisExpr`.\n\nBy default, this method calls \
-             [`ThisExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ThisExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_this_expr(&mut self, node: &ThisExpr) {
-        <ThisExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
+        <ThisExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `ThrowStmt`.\n\nBy default, this method calls \
-             [`ThrowStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`ThrowStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
-        <ThrowStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
+        <ThrowStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Tpl`.\n\nBy default, this method calls \
-             [`Tpl::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`Tpl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_tpl(&mut self, node: &Tpl) {
-        <Tpl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
+        <Tpl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TplElement`.\n\nBy default, this method calls \
-             [`TplElement::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TplElement::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_tpl_element(&mut self, node: &TplElement) {
-        <TplElement as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
+        <TplElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < TplElement >`.\n\nBy default, this method calls [`Vec < \
-             TplElement >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             TplElement >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_tpl_elements(&mut self, node: &[TplElement]) {
-        <[TplElement] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_tpl_elements(
+        &mut self,
+        node: Vec<TplElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TplElement> {
+        <Vec<TplElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TruePlusMinus`.\n\nBy default, this method calls \
-             [`TruePlusMinus::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TruePlusMinus::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
-        <TruePlusMinus as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_true_plus_minus(
+        &mut self,
+        node: TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) -> TruePlusMinus {
+        <TruePlusMinus as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TryStmt`.\n\nBy default, this method calls \
-             [`TryStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TryStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_try_stmt(&mut self, node: &TryStmt) {
-        <TryStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
+        <TryStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsArrayType`.\n\nBy default, this method calls \
-             [`TsArrayType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsArrayType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_array_type(&mut self, node: &TsArrayType) {
-        <TsArrayType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_array_type(
+        &mut self,
+        node: TsArrayType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsArrayType {
+        <TsArrayType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsAsExpr`.\n\nBy default, this method calls \
-             [`TsAsExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsAsExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
-        <TsAsExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
+        <TsAsExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsCallSignatureDecl`.\n\nBy default, this method calls \
-             [`TsCallSignatureDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsCallSignatureDecl::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
-        <TsCallSignatureDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_call_signature_decl(
+        &mut self,
+        node: TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsCallSignatureDecl {
+        <TsCallSignatureDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConditionalType`.\n\nBy default, this method calls \
-             [`TsConditionalType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsConditionalType::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
-        <TsConditionalType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_conditional_type(
+        &mut self,
+        node: TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConditionalType {
+        <TsConditionalType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstAssertion`.\n\nBy default, this method calls \
-             [`TsConstAssertion::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsConstAssertion::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
-        <TsConstAssertion as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_const_assertion(
+        &mut self,
+        node: TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstAssertion {
+        <TsConstAssertion as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstructSignatureDecl`.\n\nBy default, this method calls \
-             [`TsConstructSignatureDecl::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsConstructSignatureDecl::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
-        <TsConstructSignatureDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_construct_signature_decl(
+        &mut self,
+        node: TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructSignatureDecl {
+        <TsConstructSignatureDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsConstructorType`.\n\nBy default, this method calls \
-             [`TsConstructorType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsConstructorType::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
-        <TsConstructorType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_constructor_type(
+        &mut self,
+        node: TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructorType {
+        <TsConstructorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsEntityName`.\n\nBy default, this method calls \
-             [`TsEntityName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsEntityName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
-        <TsEntityName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_entity_name(
+        &mut self,
+        node: TsEntityName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEntityName {
+        <TsEntityName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsEnumDecl`.\n\nBy default, this method calls \
-             [`TsEnumDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsEnumDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
-        <TsEnumDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
+        <TsEnumDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsEnumMember`.\n\nBy default, this method calls \
-             [`TsEnumMember::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsEnumMember::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
-        <TsEnumMember as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_enum_member(
+        &mut self,
+        node: TsEnumMember,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMember {
+        <TsEnumMember as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsEnumMemberId`.\n\nBy default, this method calls \
-             [`TsEnumMemberId::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsEnumMemberId::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
-        <TsEnumMemberId as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_enum_member_id(
+        &mut self,
+        node: TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMemberId {
+        <TsEnumMemberId as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsEnumMember >`.\n\nBy default, this method calls [`Vec < \
-             TsEnumMember >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             TsEnumMember >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
-        <[TsEnumMember] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_enum_members(
+        &mut self,
+        node: Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsEnumMember> {
+        <Vec<TsEnumMember> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExportAssignment`.\n\nBy default, this method calls \
-             [`TsExportAssignment::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsExportAssignment::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
-        <TsExportAssignment as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_export_assignment(
+        &mut self,
+        node: TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExportAssignment {
+        <TsExportAssignment as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExprWithTypeArgs`.\n\nBy default, this method calls \
-             [`TsExprWithTypeArgs::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsExprWithTypeArgs::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs) {
-        <TsExprWithTypeArgs as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_expr_with_type_args(
+        &mut self,
+        node: TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExprWithTypeArgs {
+        <TsExprWithTypeArgs as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsExprWithTypeArgs >`.\n\nBy default, this method calls \
-             [`Vec < TsExprWithTypeArgs >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
+             [`Vec < TsExprWithTypeArgs >::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs]) {
-        <[TsExprWithTypeArgs] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_expr_with_type_argss(
+        &mut self,
+        node: Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsExprWithTypeArgs> {
+        <Vec<TsExprWithTypeArgs> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsExternalModuleRef`.\n\nBy default, this method calls \
-             [`TsExternalModuleRef::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsExternalModuleRef::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
-        <TsExternalModuleRef as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_external_module_ref(
+        &mut self,
+        node: TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExternalModuleRef {
+        <TsExternalModuleRef as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnOrConstructorType`.\n\nBy default, this method calls \
-             [`TsFnOrConstructorType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsFnOrConstructorType::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType) {
-        <TsFnOrConstructorType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_fn_or_constructor_type(
+        &mut self,
+        node: TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsFnOrConstructorType {
+        <TsFnOrConstructorType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnParam`.\n\nBy default, this method calls \
-             [`TsFnParam::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsFnParam::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
-        <TsFnParam as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
+        <TsFnParam as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < TsFnParam >`.\n\nBy default, this method calls [`Vec < \
-             TsFnParam >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             TsFnParam >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
-        <[TsFnParam] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_fn_params(
+        &mut self,
+        node: Vec<TsFnParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsFnParam> {
+        <Vec<TsFnParam> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsFnType`.\n\nBy default, this method calls \
-             [`TsFnType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsFnType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_fn_type(&mut self, node: &TsFnType) {
-        <TsFnType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
+        <TsFnType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsGetterSignature`.\n\nBy default, this method calls \
-             [`TsGetterSignature::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsGetterSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
-        <TsGetterSignature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_getter_signature(
+        &mut self,
+        node: TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsGetterSignature {
+        <TsGetterSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsImportEqualsDecl`.\n\nBy default, this method calls \
-             [`TsImportEqualsDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsImportEqualsDecl::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
-        <TsImportEqualsDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_import_equals_decl(
+        &mut self,
+        node: TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportEqualsDecl {
+        <TsImportEqualsDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsImportType`.\n\nBy default, this method calls \
-             [`TsImportType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsImportType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_import_type(&mut self, node: &TsImportType) {
-        <TsImportType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_import_type(
+        &mut self,
+        node: TsImportType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportType {
+        <TsImportType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsIndexSignature`.\n\nBy default, this method calls \
-             [`TsIndexSignature::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsIndexSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
-        <TsIndexSignature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_index_signature(
+        &mut self,
+        node: TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexSignature {
+        <TsIndexSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIndexedAccessType`.\n\nBy default, this method calls \
-             [`TsIndexedAccessType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsIndexedAccessType::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
-        <TsIndexedAccessType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_indexed_access_type(
+        &mut self,
+        node: TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexedAccessType {
+        <TsIndexedAccessType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInferType`.\n\nBy default, this method calls \
-             [`TsInferType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsInferType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_infer_type(&mut self, node: &TsInferType) {
-        <TsInferType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_infer_type(
+        &mut self,
+        node: TsInferType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInferType {
+        <TsInferType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsInstantiation`.\n\nBy default, this method calls \
-             [`TsInstantiation::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsInstantiation::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
-        <TsInstantiation as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_instantiation(
+        &mut self,
+        node: TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInstantiation {
+        <TsInstantiation as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInterfaceBody`.\n\nBy default, this method calls \
-             [`TsInterfaceBody::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsInterfaceBody::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
-        <TsInterfaceBody as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_interface_body(
+        &mut self,
+        node: TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceBody {
+        <TsInterfaceBody as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsInterfaceDecl`.\n\nBy default, this method calls \
-             [`TsInterfaceDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsInterfaceDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
-        <TsInterfaceDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_interface_decl(
+        &mut self,
+        node: TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceDecl {
+        <TsInterfaceDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsIntersectionType`.\n\nBy default, this method calls \
-             [`TsIntersectionType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsIntersectionType::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
-        <TsIntersectionType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_intersection_type(
+        &mut self,
+        node: TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIntersectionType {
+        <TsIntersectionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsKeywordType`.\n\nBy default, this method calls \
-             [`TsKeywordType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsKeywordType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
-        <TsKeywordType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_keyword_type(
+        &mut self,
+        node: TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordType {
+        <TsKeywordType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsKeywordTypeKind`.\n\nBy default, this method calls \
-             [`TsKeywordTypeKind::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsKeywordTypeKind::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
-        <TsKeywordTypeKind as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_keyword_type_kind(
+        &mut self,
+        node: TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordTypeKind {
+        <TsKeywordTypeKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsLit`.\n\nBy default, this method calls \
-             [`TsLit::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`TsLit::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_ts_lit(&mut self, node: &TsLit) {
-        <TsLit as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
+        <TsLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsLitType`.\n\nBy default, this method calls \
-             [`TsLitType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsLitType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_lit_type(&mut self, node: &TsLitType) {
-        <TsLitType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
+        <TsLitType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsMappedType`.\n\nBy default, this method calls \
-             [`TsMappedType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsMappedType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
-        <TsMappedType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_mapped_type(
+        &mut self,
+        node: TsMappedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMappedType {
+        <TsMappedType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsMethodSignature`.\n\nBy default, this method calls \
-             [`TsMethodSignature::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsMethodSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
-        <TsMethodSignature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_method_signature(
+        &mut self,
+        node: TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMethodSignature {
+        <TsMethodSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleBlock`.\n\nBy default, this method calls \
-             [`TsModuleBlock::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsModuleBlock::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
-        <TsModuleBlock as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_module_block(
+        &mut self,
+        node: TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleBlock {
+        <TsModuleBlock as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsModuleDecl`.\n\nBy default, this method calls \
-             [`TsModuleDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsModuleDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
-        <TsModuleDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_module_decl(
+        &mut self,
+        node: TsModuleDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleDecl {
+        <TsModuleDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsModuleName`.\n\nBy default, this method calls \
-             [`TsModuleName::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsModuleName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_module_name(&mut self, node: &TsModuleName) {
-        <TsModuleName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_module_name(
+        &mut self,
+        node: TsModuleName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleName {
+        <TsModuleName as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsModuleRef`.\n\nBy default, this method calls \
-             [`TsModuleRef::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsModuleRef::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
-        <TsModuleRef as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_module_ref(
+        &mut self,
+        node: TsModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleRef {
+        <TsModuleRef as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsNamespaceBody`.\n\nBy default, this method calls \
-             [`TsNamespaceBody::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsNamespaceBody::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
-        <TsNamespaceBody as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_namespace_body(
+        &mut self,
+        node: TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceBody {
+        <TsNamespaceBody as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsNamespaceDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
-        <TsNamespaceDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_namespace_decl(
+        &mut self,
+        node: TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceDecl {
+        <TsNamespaceDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNamespaceExportDecl`.\n\nBy default, this method calls \
-             [`TsNamespaceExportDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsNamespaceExportDecl::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
-        <TsNamespaceExportDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_namespace_export_decl(
+        &mut self,
+        node: TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceExportDecl {
+        <TsNamespaceExportDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsNonNullExpr`.\n\nBy default, this method calls \
-             [`TsNonNullExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsNonNullExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
-        <TsNonNullExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_non_null_expr(
+        &mut self,
+        node: TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNonNullExpr {
+        <TsNonNullExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsOptionalType`.\n\nBy default, this method calls \
-             [`TsOptionalType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsOptionalType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
-        <TsOptionalType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_optional_type(
+        &mut self,
+        node: TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsOptionalType {
+        <TsOptionalType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParamProp`.\n\nBy default, this method calls \
-             [`TsParamProp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsParamProp::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
-        <TsParamProp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_param_prop(
+        &mut self,
+        node: TsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamProp {
+        <TsParamProp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsParamPropParam`.\n\nBy default, this method calls \
-             [`TsParamPropParam::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsParamPropParam::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
-        <TsParamPropParam as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_param_prop_param(
+        &mut self,
+        node: TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamPropParam {
+        <TsParamPropParam as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsParenthesizedType`.\n\nBy default, this method calls \
-             [`TsParenthesizedType::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsParenthesizedType::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
-        <TsParenthesizedType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_parenthesized_type(
+        &mut self,
+        node: TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParenthesizedType {
+        <TsParenthesizedType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsPropertySignature`.\n\nBy default, this method calls \
-             [`TsPropertySignature::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsPropertySignature::fold_children_with_ast_path`]. If you want to recurse, you \
+             need to call it manually."]
     #[inline]
-    fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
-        <TsPropertySignature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_property_signature(
+        &mut self,
+        node: TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsPropertySignature {
+        <TsPropertySignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsQualifiedName`.\n\nBy default, this method calls \
-             [`TsQualifiedName::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsQualifiedName::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
-        <TsQualifiedName as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_qualified_name(
+        &mut self,
+        node: TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsQualifiedName {
+        <TsQualifiedName as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsRestType`.\n\nBy default, this method calls \
-             [`TsRestType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsRestType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_rest_type(&mut self, node: &TsRestType) {
-        <TsRestType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
+        <TsRestType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsSatisfiesExpr`.\n\nBy default, this method calls \
-             [`TsSatisfiesExpr::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsSatisfiesExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
-        <TsSatisfiesExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_satisfies_expr(
+        &mut self,
+        node: TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSatisfiesExpr {
+        <TsSatisfiesExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsSetterSignature`.\n\nBy default, this method calls \
-             [`TsSetterSignature::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsSetterSignature::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
-        <TsSetterSignature as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_setter_signature(
+        &mut self,
+        node: TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSetterSignature {
+        <TsSetterSignature as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsThisType`.\n\nBy default, this method calls \
-             [`TsThisType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsThisType::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_this_type(&mut self, node: &TsThisType) {
-        <TsThisType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
+        <TsThisType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsThisTypeOrIdent`.\n\nBy default, this method calls \
-             [`TsThisTypeOrIdent::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsThisTypeOrIdent::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent) {
-        <TsThisTypeOrIdent as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_this_type_or_ident(
+        &mut self,
+        node: TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> TsThisTypeOrIdent {
+        <TsThisTypeOrIdent as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTplLitType`.\n\nBy default, this method calls \
-             [`TsTplLitType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTplLitType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
-        <TsTplLitType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_tpl_lit_type(
+        &mut self,
+        node: TsTplLitType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTplLitType {
+        <TsTplLitType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTupleElement`.\n\nBy default, this method calls \
-             [`TsTupleElement::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTupleElement::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
-        <TsTupleElement as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_tuple_element(
+        &mut self,
+        node: TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleElement {
+        <TsTupleElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTupleElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTupleElement >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < TsTupleElement >::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
-        <[TsTupleElement] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_tuple_elements(
+        &mut self,
+        node: Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTupleElement> {
+        <Vec<TsTupleElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTupleType`.\n\nBy default, this method calls \
-             [`TsTupleType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTupleType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
-        <TsTupleType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_tuple_type(
+        &mut self,
+        node: TsTupleType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleType {
+        <TsTupleType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsType`.\n\nBy default, this method calls \
-             [`TsType::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
+             [`TsType::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_ts_type(&mut self, node: &TsType) {
-        <TsType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
+        <TsType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeAliasDecl`.\n\nBy default, this method calls \
-             [`TsTypeAliasDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeAliasDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
-        <TsTypeAliasDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_alias_decl(
+        &mut self,
+        node: TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAliasDecl {
+        <TsTypeAliasDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeAnn`.\n\nBy default, this method calls \
-             [`TsTypeAnn::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeAnn::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
-        <TsTypeAnn as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
+        <TsTypeAnn as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeAssertion`.\n\nBy default, this method calls \
-             [`TsTypeAssertion::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeAssertion::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
-        <TsTypeAssertion as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_assertion(
+        &mut self,
+        node: TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAssertion {
+        <TsTypeAssertion as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeElement`.\n\nBy default, this method calls \
-             [`TsTypeElement::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeElement::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
-        <TsTypeElement as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_element(
+        &mut self,
+        node: TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeElement {
+        <TsTypeElement as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTypeElement >`.\n\nBy default, this method calls [`Vec \
-             < TsTypeElement >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < TsTypeElement >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
-        <[TsTypeElement] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_elements(
+        &mut self,
+        node: Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeElement> {
+        <Vec<TsTypeElement> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeLit`.\n\nBy default, this method calls \
-             [`TsTypeLit::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeLit::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
-        <TsTypeLit as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
+        <TsTypeLit as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeOperator`.\n\nBy default, this method calls \
-             [`TsTypeOperator::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeOperator::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
-        <TsTypeOperator as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_operator(
+        &mut self,
+        node: TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperator {
+        <TsTypeOperator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeOperatorOp`.\n\nBy default, this method calls \
-             [`TsTypeOperatorOp::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeOperatorOp::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
-        <TsTypeOperatorOp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_operator_op(
+        &mut self,
+        node: TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperatorOp {
+        <TsTypeOperatorOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParam`.\n\nBy default, this method calls \
-             [`TsTypeParam::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeParam::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
-        <TsTypeParam as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_param(
+        &mut self,
+        node: TsTypeParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParam {
+        <TsTypeParam as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeParamDecl`.\n\nBy default, this method calls \
-             [`TsTypeParamDecl::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeParamDecl::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
-        <TsTypeParamDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_param_decl(
+        &mut self,
+        node: TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamDecl {
+        <TsTypeParamDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeParamInstantiation`.\n\nBy default, this method calls \
-             [`TsTypeParamInstantiation::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeParamInstantiation::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
-        <TsTypeParamInstantiation as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_param_instantiation(
+        &mut self,
+        node: TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamInstantiation {
+        <TsTypeParamInstantiation as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < TsTypeParam >`.\n\nBy default, this method calls [`Vec < \
-             TsTypeParam >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             TsTypeParam >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
-        <[TsTypeParam] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_params(
+        &mut self,
+        node: Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeParam> {
+        <Vec<TsTypeParam> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypePredicate`.\n\nBy default, this method calls \
-             [`TsTypePredicate::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypePredicate::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
-        <TsTypePredicate as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_predicate(
+        &mut self,
+        node: TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypePredicate {
+        <TsTypePredicate as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeQuery`.\n\nBy default, this method calls \
-             [`TsTypeQuery::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeQuery::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
-        <TsTypeQuery as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_query(
+        &mut self,
+        node: TsTypeQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQuery {
+        <TsTypeQuery as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `TsTypeQueryExpr`.\n\nBy default, this method calls \
-             [`TsTypeQueryExpr::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeQueryExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
-        <TsTypeQueryExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_query_expr(
+        &mut self,
+        node: TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQueryExpr {
+        <TsTypeQueryExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsTypeRef`.\n\nBy default, this method calls \
-             [`TsTypeRef::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsTypeRef::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
-        <TsTypeRef as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
+        <TsTypeRef as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Box < TsType > >`.\n\nBy default, this method calls [`Vec \
-             < Box < TsType > >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < Box < TsType > >::fold_children_with_ast_path`]. If you want to recurse, you need \
+             to call it manually."]
     #[inline]
-    fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
-        <[Box<TsType>] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_types(
+        &mut self,
+        node: Vec<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Box<TsType>> {
+        <Vec<Box<TsType>> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsUnionOrIntersectionType`.\n\nBy default, this method calls \
-             [`TsUnionOrIntersectionType::visit_children_with`]. This method unconditionally calls \
-             the visitor method for all children because it's defined in the trait [VisitAll]."]
+             [`TsUnionOrIntersectionType::fold_children_with_ast_path`]. If you want to recurse, \
+             you need to call it manually."]
     #[inline]
-    fn visit_ts_union_or_intersection_type(&mut self, node: &TsUnionOrIntersectionType) {
-        <TsUnionOrIntersectionType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_union_or_intersection_type(
+        &mut self,
+        node: TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionOrIntersectionType {
+        <TsUnionOrIntersectionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `TsUnionType`.\n\nBy default, this method calls \
-             [`TsUnionType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`TsUnionType::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_ts_union_type(&mut self, node: &TsUnionType) {
-        <TsUnionType as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_ts_union_type(
+        &mut self,
+        node: TsUnionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionType {
+        <TsUnionType as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UnaryExpr`.\n\nBy default, this method calls \
-             [`UnaryExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UnaryExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_unary_expr(&mut self, node: &UnaryExpr) {
-        <UnaryExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
+        <UnaryExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UnaryOp`.\n\nBy default, this method calls \
-             [`UnaryOp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UnaryOp::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_unary_op(&mut self, node: &UnaryOp) {
-        <UnaryOp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
+        <UnaryOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UpdateExpr`.\n\nBy default, this method calls \
-             [`UpdateExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UpdateExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_update_expr(&mut self, node: &UpdateExpr) {
-        <UpdateExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
+        <UpdateExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UpdateOp`.\n\nBy default, this method calls \
-             [`UpdateOp::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UpdateOp::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_update_op(&mut self, node: &UpdateOp) {
-        <UpdateOp as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
+        <UpdateOp as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `UsingDecl`.\n\nBy default, this method calls \
-             [`UsingDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`UsingDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_using_decl(&mut self, node: &UsingDecl) {
-        <UsingDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
+        <UsingDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `VarDecl`.\n\nBy default, this method calls \
-             [`VarDecl::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`VarDecl::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
+             manually."]
     #[inline]
-    fn visit_var_decl(&mut self, node: &VarDecl) {
-        <VarDecl as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
+        <VarDecl as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `VarDeclKind`.\n\nBy default, this method calls \
-             [`VarDeclKind::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`VarDeclKind::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
-        <VarDeclKind as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_var_decl_kind(
+        &mut self,
+        node: VarDeclKind,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclKind {
+        <VarDeclKind as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `VarDeclOrExpr`.\n\nBy default, this method calls \
-             [`VarDeclOrExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`VarDeclOrExpr::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
-        <VarDeclOrExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_var_decl_or_expr(
+        &mut self,
+        node: VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclOrExpr {
+        <VarDeclOrExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `VarDeclarator`.\n\nBy default, this method calls \
-             [`VarDeclarator::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`VarDeclarator::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_var_declarator(&mut self, node: &VarDeclarator) {
-        <VarDeclarator as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_var_declarator(
+        &mut self,
+        node: VarDeclarator,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclarator {
+        <VarDeclarator as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `Vec < VarDeclarator >`.\n\nBy default, this method calls [`Vec \
-             < VarDeclarator >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
+             < VarDeclarator >::fold_children_with_ast_path`]. If you want to recurse, you need to \
+             call it manually."]
     #[inline]
-    fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
-        <[VarDeclarator] as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_var_declarators(
+        &mut self,
+        node: Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<VarDeclarator> {
+        <Vec<VarDeclarator> as FoldWithAstPath<Self>>::fold_children_with_ast_path(
+            node, self, __ast_path,
+        )
     }
     #[doc = "Visit a node of type `WhileStmt`.\n\nBy default, this method calls \
-             [`WhileStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`WhileStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_while_stmt(&mut self, node: &WhileStmt) {
-        <WhileStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
+        <WhileStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `WithStmt`.\n\nBy default, this method calls \
-             [`WithStmt::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`WithStmt::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_with_stmt(&mut self, node: &WithStmt) {
-        <WithStmt as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
+        <WithStmt as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `YieldExpr`.\n\nBy default, this method calls \
-             [`YieldExpr::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
+             [`YieldExpr::fold_children_with_ast_path`]. If you want to recurse, you need to call \
+             it manually."]
     #[inline]
-    fn visit_yield_expr(&mut self, node: &YieldExpr) {
-        <YieldExpr as VisitAllWith<Self>>::visit_children_with(node, self)
+    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
+        <YieldExpr as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
 }
-impl<V> VisitAll for &mut V
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> FoldAstPath for &mut V
 where
-    V: ?Sized + VisitAll,
+    V: ?Sized + FoldAstPath,
 {
     #[inline]
-    fn visit_accessibility(&mut self, node: &Accessibility) {
-        <V as VisitAll>::visit_accessibility(&mut **self, node)
+    fn fold_accessibility(
+        &mut self,
+        node: Accessibility,
+        __ast_path: &mut AstKindPath,
+    ) -> Accessibility {
+        <V as FoldAstPath>::fold_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_array_lit(&mut self, node: &ArrayLit) {
-        <V as VisitAll>::visit_array_lit(&mut **self, node)
+    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
+        <V as FoldAstPath>::fold_array_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_array_pat(&mut self, node: &ArrayPat) {
-        <V as VisitAll>::visit_array_pat(&mut **self, node)
+    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
+        <V as FoldAstPath>::fold_array_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
-        <V as VisitAll>::visit_arrow_expr(&mut **self, node)
+    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
+        <V as FoldAstPath>::fold_arrow_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_expr(&mut self, node: &AssignExpr) {
-        <V as VisitAll>::visit_assign_expr(&mut **self, node)
+    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
+        <V as FoldAstPath>::fold_assign_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_op(&mut self, node: &AssignOp) {
-        <V as VisitAll>::visit_assign_op(&mut **self, node)
+    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
+        <V as FoldAstPath>::fold_assign_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_pat(&mut self, node: &AssignPat) {
-        <V as VisitAll>::visit_assign_pat(&mut **self, node)
+    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
+        <V as FoldAstPath>::fold_assign_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
-        <V as VisitAll>::visit_assign_pat_prop(&mut **self, node)
+    fn fold_assign_pat_prop(
+        &mut self,
+        node: AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignPatProp {
+        <V as FoldAstPath>::fold_assign_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_prop(&mut self, node: &AssignProp) {
-        <V as VisitAll>::visit_assign_prop(&mut **self, node)
+    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
+        <V as FoldAstPath>::fold_assign_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_target(&mut self, node: &AssignTarget) {
-        <V as VisitAll>::visit_assign_target(&mut **self, node)
+    fn fold_assign_target(
+        &mut self,
+        node: AssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTarget {
+        <V as FoldAstPath>::fold_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
-        <V as VisitAll>::visit_assign_target_pat(&mut **self, node)
+    fn fold_assign_target_pat(
+        &mut self,
+        node: AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTargetPat {
+        <V as FoldAstPath>::fold_assign_target_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
+        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
-        <V as VisitAll>::visit_auto_accessor(&mut **self, node)
+    fn fold_auto_accessor(
+        &mut self,
+        node: AutoAccessor,
+        __ast_path: &mut AstKindPath,
+    ) -> AutoAccessor {
+        <V as FoldAstPath>::fold_auto_accessor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_await_expr(&mut self, node: &AwaitExpr) {
-        <V as VisitAll>::visit_await_expr(&mut **self, node)
+    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
+        <V as FoldAstPath>::fold_await_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_big_int(&mut self, node: &BigInt) {
-        <V as VisitAll>::visit_big_int(&mut **self, node)
+    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
+        <V as FoldAstPath>::fold_big_int(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_big_int_value(&mut self, node: &BigIntValue) {
-        <V as VisitAll>::visit_big_int_value(&mut **self, node)
+    fn fold_big_int_value(
+        &mut self,
+        node: BigIntValue,
+        __ast_path: &mut AstKindPath,
+    ) -> BigIntValue {
+        <V as FoldAstPath>::fold_big_int_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_bin_expr(&mut self, node: &BinExpr) {
-        <V as VisitAll>::visit_bin_expr(&mut **self, node)
+    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
+        <V as FoldAstPath>::fold_bin_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_binary_op(&mut self, node: &BinaryOp) {
-        <V as VisitAll>::visit_binary_op(&mut **self, node)
+    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
+        <V as FoldAstPath>::fold_binary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_binding_ident(&mut self, node: &BindingIdent) {
-        <V as VisitAll>::visit_binding_ident(&mut **self, node)
+    fn fold_binding_ident(
+        &mut self,
+        node: BindingIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> BindingIdent {
+        <V as FoldAstPath>::fold_binding_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_block_stmt(&mut self, node: &BlockStmt) {
-        <V as VisitAll>::visit_block_stmt(&mut **self, node)
+    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
+        <V as FoldAstPath>::fold_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
-        <V as VisitAll>::visit_block_stmt_or_expr(&mut **self, node)
+    fn fold_block_stmt_or_expr(
+        &mut self,
+        node: BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> BlockStmtOrExpr {
+        <V as FoldAstPath>::fold_block_stmt_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_bool(&mut self, node: &Bool) {
-        <V as VisitAll>::visit_bool(&mut **self, node)
+    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
+        <V as FoldAstPath>::fold_bool(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_break_stmt(&mut self, node: &BreakStmt) {
-        <V as VisitAll>::visit_break_stmt(&mut **self, node)
+    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
+        <V as FoldAstPath>::fold_break_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_call_expr(&mut self, node: &CallExpr) {
-        <V as VisitAll>::visit_call_expr(&mut **self, node)
+    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
+        <V as FoldAstPath>::fold_call_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_callee(&mut self, node: &Callee) {
-        <V as VisitAll>::visit_callee(&mut **self, node)
+    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
+        <V as FoldAstPath>::fold_callee(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_catch_clause(&mut self, node: &CatchClause) {
-        <V as VisitAll>::visit_catch_clause(&mut **self, node)
+    fn fold_catch_clause(
+        &mut self,
+        node: CatchClause,
+        __ast_path: &mut AstKindPath,
+    ) -> CatchClause {
+        <V as FoldAstPath>::fold_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class(&mut self, node: &Class) {
-        <V as VisitAll>::visit_class(&mut **self, node)
+    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
+        <V as FoldAstPath>::fold_class(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_decl(&mut self, node: &ClassDecl) {
-        <V as VisitAll>::visit_class_decl(&mut **self, node)
+    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
+        <V as FoldAstPath>::fold_class_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_expr(&mut self, node: &ClassExpr) {
-        <V as VisitAll>::visit_class_expr(&mut **self, node)
+    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
+        <V as FoldAstPath>::fold_class_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_member(&mut self, node: &ClassMember) {
-        <V as VisitAll>::visit_class_member(&mut **self, node)
+    fn fold_class_member(
+        &mut self,
+        node: ClassMember,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMember {
+        <V as FoldAstPath>::fold_class_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_members(&mut self, node: &[ClassMember]) {
-        <V as VisitAll>::visit_class_members(&mut **self, node)
+    fn fold_class_members(
+        &mut self,
+        node: Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ClassMember> {
+        <V as FoldAstPath>::fold_class_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_method(&mut self, node: &ClassMethod) {
-        <V as VisitAll>::visit_class_method(&mut **self, node)
+    fn fold_class_method(
+        &mut self,
+        node: ClassMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMethod {
+        <V as FoldAstPath>::fold_class_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_prop(&mut self, node: &ClassProp) {
-        <V as VisitAll>::visit_class_prop(&mut **self, node)
+    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
+        <V as FoldAstPath>::fold_class_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
-        <V as VisitAll>::visit_computed_prop_name(&mut **self, node)
+    fn fold_computed_prop_name(
+        &mut self,
+        node: ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) -> ComputedPropName {
+        <V as FoldAstPath>::fold_computed_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_cond_expr(&mut self, node: &CondExpr) {
-        <V as VisitAll>::visit_cond_expr(&mut **self, node)
+    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
+        <V as FoldAstPath>::fold_cond_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_constructor(&mut self, node: &Constructor) {
-        <V as VisitAll>::visit_constructor(&mut **self, node)
+    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
+        <V as FoldAstPath>::fold_constructor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
-        <V as VisitAll>::visit_continue_stmt(&mut **self, node)
+    fn fold_continue_stmt(
+        &mut self,
+        node: ContinueStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> ContinueStmt {
+        <V as FoldAstPath>::fold_continue_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
-        <V as VisitAll>::visit_debugger_stmt(&mut **self, node)
+    fn fold_debugger_stmt(
+        &mut self,
+        node: DebuggerStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DebuggerStmt {
+        <V as FoldAstPath>::fold_debugger_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_decl(&mut self, node: &Decl) {
-        <V as VisitAll>::visit_decl(&mut **self, node)
+    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
+        <V as FoldAstPath>::fold_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_decorator(&mut self, node: &Decorator) {
-        <V as VisitAll>::visit_decorator(&mut **self, node)
+    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
+        <V as FoldAstPath>::fold_decorator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_decorators(&mut self, node: &[Decorator]) {
-        <V as VisitAll>::visit_decorators(&mut **self, node)
+    fn fold_decorators(
+        &mut self,
+        node: Vec<Decorator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Decorator> {
+        <V as FoldAstPath>::fold_decorators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_default_decl(&mut self, node: &DefaultDecl) {
-        <V as VisitAll>::visit_default_decl(&mut **self, node)
+    fn fold_default_decl(
+        &mut self,
+        node: DefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> DefaultDecl {
+        <V as FoldAstPath>::fold_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
-        <V as VisitAll>::visit_do_while_stmt(&mut **self, node)
+    fn fold_do_while_stmt(
+        &mut self,
+        node: DoWhileStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DoWhileStmt {
+        <V as FoldAstPath>::fold_do_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
-        <V as VisitAll>::visit_empty_stmt(&mut **self, node)
+    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
+        <V as FoldAstPath>::fold_empty_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_es_version(&mut self, node: &EsVersion) {
-        <V as VisitAll>::visit_es_version(&mut **self, node)
+    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
+        <V as FoldAstPath>::fold_es_version(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_all(&mut self, node: &ExportAll) {
-        <V as VisitAll>::visit_export_all(&mut **self, node)
+    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
+        <V as FoldAstPath>::fold_export_all(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_decl(&mut self, node: &ExportDecl) {
-        <V as VisitAll>::visit_export_decl(&mut **self, node)
+    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
+        <V as FoldAstPath>::fold_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
-        <V as VisitAll>::visit_export_default_decl(&mut **self, node)
+    fn fold_export_default_decl(
+        &mut self,
+        node: ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultDecl {
+        <V as FoldAstPath>::fold_export_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
-        <V as VisitAll>::visit_export_default_expr(&mut **self, node)
+    fn fold_export_default_expr(
+        &mut self,
+        node: ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultExpr {
+        <V as FoldAstPath>::fold_export_default_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
-        <V as VisitAll>::visit_export_default_specifier(&mut **self, node)
+    fn fold_export_default_specifier(
+        &mut self,
+        node: ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultSpecifier {
+        <V as FoldAstPath>::fold_export_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
-        <V as VisitAll>::visit_export_named_specifier(&mut **self, node)
+    fn fold_export_named_specifier(
+        &mut self,
+        node: ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamedSpecifier {
+        <V as FoldAstPath>::fold_export_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
-        <V as VisitAll>::visit_export_namespace_specifier(&mut **self, node)
+    fn fold_export_namespace_specifier(
+        &mut self,
+        node: ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamespaceSpecifier {
+        <V as FoldAstPath>::fold_export_namespace_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
-        <V as VisitAll>::visit_export_specifier(&mut **self, node)
+    fn fold_export_specifier(
+        &mut self,
+        node: ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportSpecifier {
+        <V as FoldAstPath>::fold_export_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
-        <V as VisitAll>::visit_export_specifiers(&mut **self, node)
+    fn fold_export_specifiers(
+        &mut self,
+        node: Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExportSpecifier> {
+        <V as FoldAstPath>::fold_export_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr(&mut self, node: &Expr) {
-        <V as VisitAll>::visit_expr(&mut **self, node)
+    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
+        <V as FoldAstPath>::fold_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
-        <V as VisitAll>::visit_expr_or_spread(&mut **self, node)
+    fn fold_expr_or_spread(
+        &mut self,
+        node: ExprOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> ExprOrSpread {
+        <V as FoldAstPath>::fold_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
-        <V as VisitAll>::visit_expr_or_spreads(&mut **self, node)
+    fn fold_expr_or_spreads(
+        &mut self,
+        node: Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExprOrSpread> {
+        <V as FoldAstPath>::fold_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr_stmt(&mut self, node: &ExprStmt) {
-        <V as VisitAll>::visit_expr_stmt(&mut **self, node)
+    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
+        <V as FoldAstPath>::fold_expr_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_exprs(&mut self, node: &[Box<Expr>]) {
-        <V as VisitAll>::visit_exprs(&mut **self, node)
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
+        <V as FoldAstPath>::fold_exprs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_fn_decl(&mut self, node: &FnDecl) {
-        <V as VisitAll>::visit_fn_decl(&mut **self, node)
+    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
+        <V as FoldAstPath>::fold_fn_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_fn_expr(&mut self, node: &FnExpr) {
-        <V as VisitAll>::visit_fn_expr(&mut **self, node)
+    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
+        <V as FoldAstPath>::fold_fn_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_head(&mut self, node: &ForHead) {
-        <V as VisitAll>::visit_for_head(&mut **self, node)
+    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
+        <V as FoldAstPath>::fold_for_head(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
-        <V as VisitAll>::visit_for_in_stmt(&mut **self, node)
+    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
+        <V as FoldAstPath>::fold_for_in_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
-        <V as VisitAll>::visit_for_of_stmt(&mut **self, node)
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
+        <V as FoldAstPath>::fold_for_of_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_stmt(&mut self, node: &ForStmt) {
-        <V as VisitAll>::visit_for_stmt(&mut **self, node)
+    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
+        <V as FoldAstPath>::fold_for_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <V as VisitAll>::visit_function(&mut **self, node)
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_getter_prop(&mut self, node: &GetterProp) {
-        <V as VisitAll>::visit_getter_prop(&mut **self, node)
+    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
+        <V as FoldAstPath>::fold_getter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <V as VisitAll>::visit_ident(&mut **self, node)
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ident_name(&mut self, node: &IdentName) {
-        <V as VisitAll>::visit_ident_name(&mut **self, node)
+    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
+        <V as FoldAstPath>::fold_ident_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_if_stmt(&mut self, node: &IfStmt) {
-        <V as VisitAll>::visit_if_stmt(&mut **self, node)
+    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
+        <V as FoldAstPath>::fold_if_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import(&mut self, node: &Import) {
-        <V as VisitAll>::visit_import(&mut **self, node)
+    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
+        <V as FoldAstPath>::fold_import(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_decl(&mut self, node: &ImportDecl) {
-        <V as VisitAll>::visit_import_decl(&mut **self, node)
+    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
+        <V as FoldAstPath>::fold_import_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
-        <V as VisitAll>::visit_import_default_specifier(&mut **self, node)
+    fn fold_import_default_specifier(
+        &mut self,
+        node: ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportDefaultSpecifier {
+        <V as FoldAstPath>::fold_import_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
-        <V as VisitAll>::visit_import_named_specifier(&mut **self, node)
+    fn fold_import_named_specifier(
+        &mut self,
+        node: ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportNamedSpecifier {
+        <V as FoldAstPath>::fold_import_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_phase(&mut self, node: &ImportPhase) {
-        <V as VisitAll>::visit_import_phase(&mut **self, node)
+    fn fold_import_phase(
+        &mut self,
+        node: ImportPhase,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPhase {
+        <V as FoldAstPath>::fold_import_phase(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
-        <V as VisitAll>::visit_import_specifier(&mut **self, node)
+    fn fold_import_specifier(
+        &mut self,
+        node: ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportSpecifier {
+        <V as FoldAstPath>::fold_import_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
-        <V as VisitAll>::visit_import_specifiers(&mut **self, node)
+    fn fold_import_specifiers(
+        &mut self,
+        node: Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportSpecifier> {
+        <V as FoldAstPath>::fold_import_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
-        <V as VisitAll>::visit_import_star_as_specifier(&mut **self, node)
+    fn fold_import_star_as_specifier(
+        &mut self,
+        node: ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportStarAsSpecifier {
+        <V as FoldAstPath>::fold_import_star_as_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_with(&mut self, node: &ImportWith) {
-        <V as VisitAll>::visit_import_with(&mut **self, node)
+    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
+        <V as FoldAstPath>::fold_import_with(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_with_item(&mut self, node: &ImportWithItem) {
-        <V as VisitAll>::visit_import_with_item(&mut **self, node)
+    fn fold_import_with_item(
+        &mut self,
+        node: ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportWithItem {
+        <V as FoldAstPath>::fold_import_with_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
-        <V as VisitAll>::visit_import_with_items(&mut **self, node)
+    fn fold_import_with_items(
+        &mut self,
+        node: Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportWithItem> {
+        <V as FoldAstPath>::fold_import_with_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_invalid(&mut self, node: &Invalid) {
-        <V as VisitAll>::visit_invalid(&mut **self, node)
+    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
+        <V as FoldAstPath>::fold_invalid(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr(&mut self, node: &JSXAttr) {
-        <V as VisitAll>::visit_jsx_attr(&mut **self, node)
+    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
+        <V as FoldAstPath>::fold_jsx_attr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
-        <V as VisitAll>::visit_jsx_attr_name(&mut **self, node)
+    fn fold_jsx_attr_name(
+        &mut self,
+        node: JSXAttrName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrName {
+        <V as FoldAstPath>::fold_jsx_attr_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
-        <V as VisitAll>::visit_jsx_attr_or_spread(&mut **self, node)
+    fn fold_jsx_attr_or_spread(
+        &mut self,
+        node: JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrOrSpread {
+        <V as FoldAstPath>::fold_jsx_attr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
-        <V as VisitAll>::visit_jsx_attr_or_spreads(&mut **self, node)
+    fn fold_jsx_attr_or_spreads(
+        &mut self,
+        node: Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXAttrOrSpread> {
+        <V as FoldAstPath>::fold_jsx_attr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
-        <V as VisitAll>::visit_jsx_attr_value(&mut **self, node)
+    fn fold_jsx_attr_value(
+        &mut self,
+        node: JSXAttrValue,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrValue {
+        <V as FoldAstPath>::fold_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
-        <V as VisitAll>::visit_jsx_closing_element(&mut **self, node)
+    fn fold_jsx_closing_element(
+        &mut self,
+        node: JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingElement {
+        <V as FoldAstPath>::fold_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
-        <V as VisitAll>::visit_jsx_closing_fragment(&mut **self, node)
+    fn fold_jsx_closing_fragment(
+        &mut self,
+        node: JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingFragment {
+        <V as FoldAstPath>::fold_jsx_closing_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element(&mut self, node: &JSXElement) {
-        <V as VisitAll>::visit_jsx_element(&mut **self, node)
+    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
+        <V as FoldAstPath>::fold_jsx_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
-        <V as VisitAll>::visit_jsx_element_child(&mut **self, node)
+    fn fold_jsx_element_child(
+        &mut self,
+        node: JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementChild {
+        <V as FoldAstPath>::fold_jsx_element_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
-        <V as VisitAll>::visit_jsx_element_childs(&mut **self, node)
+    fn fold_jsx_element_childs(
+        &mut self,
+        node: Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXElementChild> {
+        <V as FoldAstPath>::fold_jsx_element_childs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
-        <V as VisitAll>::visit_jsx_element_name(&mut **self, node)
+    fn fold_jsx_element_name(
+        &mut self,
+        node: JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementName {
+        <V as FoldAstPath>::fold_jsx_element_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
-        <V as VisitAll>::visit_jsx_empty_expr(&mut **self, node)
+    fn fold_jsx_empty_expr(
+        &mut self,
+        node: JSXEmptyExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXEmptyExpr {
+        <V as FoldAstPath>::fold_jsx_empty_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_expr(&mut self, node: &JSXExpr) {
-        <V as VisitAll>::visit_jsx_expr(&mut **self, node)
+    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
+        <V as FoldAstPath>::fold_jsx_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
-        <V as VisitAll>::visit_jsx_expr_container(&mut **self, node)
+    fn fold_jsx_expr_container(
+        &mut self,
+        node: JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXExprContainer {
+        <V as FoldAstPath>::fold_jsx_expr_container(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
-        <V as VisitAll>::visit_jsx_fragment(&mut **self, node)
+    fn fold_jsx_fragment(
+        &mut self,
+        node: JSXFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXFragment {
+        <V as FoldAstPath>::fold_jsx_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
-        <V as VisitAll>::visit_jsx_member_expr(&mut **self, node)
+    fn fold_jsx_member_expr(
+        &mut self,
+        node: JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXMemberExpr {
+        <V as FoldAstPath>::fold_jsx_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
-        <V as VisitAll>::visit_jsx_namespaced_name(&mut **self, node)
+    fn fold_jsx_namespaced_name(
+        &mut self,
+        node: JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXNamespacedName {
+        <V as FoldAstPath>::fold_jsx_namespaced_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_object(&mut self, node: &JSXObject) {
-        <V as VisitAll>::visit_jsx_object(&mut **self, node)
+    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
+        <V as FoldAstPath>::fold_jsx_object(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
-        <V as VisitAll>::visit_jsx_opening_element(&mut **self, node)
+    fn fold_jsx_opening_element(
+        &mut self,
+        node: JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningElement {
+        <V as FoldAstPath>::fold_jsx_opening_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
-        <V as VisitAll>::visit_jsx_opening_fragment(&mut **self, node)
+    fn fold_jsx_opening_fragment(
+        &mut self,
+        node: JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningFragment {
+        <V as FoldAstPath>::fold_jsx_opening_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
-        <V as VisitAll>::visit_jsx_spread_child(&mut **self, node)
+    fn fold_jsx_spread_child(
+        &mut self,
+        node: JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXSpreadChild {
+        <V as FoldAstPath>::fold_jsx_spread_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_text(&mut self, node: &JSXText) {
-        <V as VisitAll>::visit_jsx_text(&mut **self, node)
+    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
+        <V as FoldAstPath>::fold_jsx_text(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_key(&mut self, node: &Key) {
-        <V as VisitAll>::visit_key(&mut **self, node)
+    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
+        <V as FoldAstPath>::fold_key(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
-        <V as VisitAll>::visit_key_value_pat_prop(&mut **self, node)
+    fn fold_key_value_pat_prop(
+        &mut self,
+        node: KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValuePatProp {
+        <V as FoldAstPath>::fold_key_value_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
-        <V as VisitAll>::visit_key_value_prop(&mut **self, node)
+    fn fold_key_value_prop(
+        &mut self,
+        node: KeyValueProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValueProp {
+        <V as FoldAstPath>::fold_key_value_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
-        <V as VisitAll>::visit_labeled_stmt(&mut **self, node)
+    fn fold_labeled_stmt(
+        &mut self,
+        node: LabeledStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> LabeledStmt {
+        <V as FoldAstPath>::fold_labeled_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_lit(&mut self, node: &Lit) {
-        <V as VisitAll>::visit_lit(&mut **self, node)
+    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
+        <V as FoldAstPath>::fold_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_member_expr(&mut self, node: &MemberExpr) {
-        <V as VisitAll>::visit_member_expr(&mut **self, node)
+    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
+        <V as FoldAstPath>::fold_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_member_prop(&mut self, node: &MemberProp) {
-        <V as VisitAll>::visit_member_prop(&mut **self, node)
+    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
+        <V as FoldAstPath>::fold_member_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
-        <V as VisitAll>::visit_meta_prop_expr(&mut **self, node)
+    fn fold_meta_prop_expr(
+        &mut self,
+        node: MetaPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropExpr {
+        <V as FoldAstPath>::fold_meta_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
-        <V as VisitAll>::visit_meta_prop_kind(&mut **self, node)
+    fn fold_meta_prop_kind(
+        &mut self,
+        node: MetaPropKind,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropKind {
+        <V as FoldAstPath>::fold_meta_prop_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_method_kind(&mut self, node: &MethodKind) {
-        <V as VisitAll>::visit_method_kind(&mut **self, node)
+    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
+        <V as FoldAstPath>::fold_method_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_method_prop(&mut self, node: &MethodProp) {
-        <V as VisitAll>::visit_method_prop(&mut **self, node)
+    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
+        <V as FoldAstPath>::fold_method_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module(&mut self, node: &Module) {
-        <V as VisitAll>::visit_module(&mut **self, node)
+    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
+        <V as FoldAstPath>::fold_module(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_decl(&mut self, node: &ModuleDecl) {
-        <V as VisitAll>::visit_module_decl(&mut **self, node)
+    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
+        <V as FoldAstPath>::fold_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_export_name(&mut self, node: &ModuleExportName) {
-        <V as VisitAll>::visit_module_export_name(&mut **self, node)
+    fn fold_module_export_name(
+        &mut self,
+        node: ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) -> ModuleExportName {
+        <V as FoldAstPath>::fold_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_item(&mut self, node: &ModuleItem) {
-        <V as VisitAll>::visit_module_item(&mut **self, node)
+    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
+        <V as FoldAstPath>::fold_module_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_items(&mut self, node: &[ModuleItem]) {
-        <V as VisitAll>::visit_module_items(&mut **self, node)
+    fn fold_module_items(
+        &mut self,
+        node: Vec<ModuleItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ModuleItem> {
+        <V as FoldAstPath>::fold_module_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_named_export(&mut self, node: &NamedExport) {
-        <V as VisitAll>::visit_named_export(&mut **self, node)
+    fn fold_named_export(
+        &mut self,
+        node: NamedExport,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedExport {
+        <V as FoldAstPath>::fold_named_export(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_new_expr(&mut self, node: &NewExpr) {
-        <V as VisitAll>::visit_new_expr(&mut **self, node)
+    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
+        <V as FoldAstPath>::fold_new_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_null(&mut self, node: &Null) {
-        <V as VisitAll>::visit_null(&mut **self, node)
+    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
+        <V as FoldAstPath>::fold_null(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <V as VisitAll>::visit_number(&mut **self, node)
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_lit(&mut self, node: &ObjectLit) {
-        <V as VisitAll>::visit_object_lit(&mut **self, node)
+    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
+        <V as FoldAstPath>::fold_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_pat(&mut self, node: &ObjectPat) {
-        <V as VisitAll>::visit_object_pat(&mut **self, node)
+    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
+        <V as FoldAstPath>::fold_object_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
-        <V as VisitAll>::visit_object_pat_prop(&mut **self, node)
+    fn fold_object_pat_prop(
+        &mut self,
+        node: ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ObjectPatProp {
+        <V as FoldAstPath>::fold_object_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
-        <V as VisitAll>::visit_object_pat_props(&mut **self, node)
+    fn fold_object_pat_props(
+        &mut self,
+        node: Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ObjectPatProp> {
+        <V as FoldAstPath>::fold_object_pat_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
-        <V as VisitAll>::visit_opt_accessibility(&mut **self, node)
+    fn fold_opt_accessibility(
+        &mut self,
+        node: Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Accessibility> {
+        <V as FoldAstPath>::fold_opt_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
+        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>) {
-        <V as VisitAll>::visit_opt_block_stmt(&mut **self, node)
+    fn fold_opt_block_stmt(
+        &mut self,
+        node: Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<BlockStmt> {
+        <V as FoldAstPath>::fold_opt_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_call(&mut self, node: &OptCall) {
-        <V as VisitAll>::visit_opt_call(&mut **self, node)
+    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
+        <V as FoldAstPath>::fold_opt_call(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>) {
-        <V as VisitAll>::visit_opt_catch_clause(&mut **self, node)
+    fn fold_opt_catch_clause(
+        &mut self,
+        node: Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<CatchClause> {
+        <V as FoldAstPath>::fold_opt_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
-        <V as VisitAll>::visit_opt_chain_base(&mut **self, node)
+    fn fold_opt_chain_base(
+        &mut self,
+        node: OptChainBase,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainBase {
+        <V as FoldAstPath>::fold_opt_chain_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
-        <V as VisitAll>::visit_opt_chain_expr(&mut **self, node)
+    fn fold_opt_chain_expr(
+        &mut self,
+        node: OptChainExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainExpr {
+        <V as FoldAstPath>::fold_opt_chain_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>) {
-        <V as VisitAll>::visit_opt_expr(&mut **self, node)
+    fn fold_opt_expr(
+        &mut self,
+        node: Option<Box<Expr>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Expr>> {
+        <V as FoldAstPath>::fold_opt_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>) {
-        <V as VisitAll>::visit_opt_expr_or_spread(&mut **self, node)
+    fn fold_opt_expr_or_spread(
+        &mut self,
+        node: Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ExprOrSpread> {
+        <V as FoldAstPath>::fold_opt_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>) {
-        <V as VisitAll>::visit_opt_expr_or_spreads(&mut **self, node)
+    fn fold_opt_expr_or_spreads(
+        &mut self,
+        node: Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<ExprOrSpread>> {
+        <V as FoldAstPath>::fold_opt_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <V as VisitAll>::visit_opt_ident(&mut **self, node)
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
+        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>) {
-        <V as VisitAll>::visit_opt_jsx_attr_value(&mut **self, node)
+    fn fold_opt_jsx_attr_value(
+        &mut self,
+        node: Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXAttrValue> {
+        <V as FoldAstPath>::fold_opt_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>) {
-        <V as VisitAll>::visit_opt_jsx_closing_element(&mut **self, node)
+    fn fold_opt_jsx_closing_element(
+        &mut self,
+        node: Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXClosingElement> {
+        <V as FoldAstPath>::fold_opt_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_module_export_name(&mut self, node: &Option<ModuleExportName>) {
-        <V as VisitAll>::visit_opt_module_export_name(&mut **self, node)
+    fn fold_opt_module_export_name(
+        &mut self,
+        node: Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ModuleExportName> {
+        <V as FoldAstPath>::fold_opt_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_object_lit(&mut self, node: &Option<Box<ObjectLit>>) {
-        <V as VisitAll>::visit_opt_object_lit(&mut **self, node)
+    fn fold_opt_object_lit(
+        &mut self,
+        node: Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ObjectLit>> {
+        <V as FoldAstPath>::fold_opt_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_pat(&mut self, node: &Option<Pat>) {
-        <V as VisitAll>::visit_opt_pat(&mut **self, node)
+    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
+        <V as FoldAstPath>::fold_opt_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_span(&mut self, node: &Option<swc_common::Span>) {
-        <V as VisitAll>::visit_opt_span(&mut **self, node)
+    fn fold_opt_span(
+        &mut self,
+        node: Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_common::Span> {
+        <V as FoldAstPath>::fold_opt_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>) {
-        <V as VisitAll>::visit_opt_stmt(&mut **self, node)
+    fn fold_opt_stmt(
+        &mut self,
+        node: Option<Box<Stmt>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Stmt>> {
+        <V as FoldAstPath>::fold_opt_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_str(&mut self, node: &Option<Box<Str>>) {
-        <V as VisitAll>::visit_opt_str(&mut **self, node)
+    fn fold_opt_str(
+        &mut self,
+        node: Option<Box<Str>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Str>> {
+        <V as FoldAstPath>::fold_opt_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>) {
-        <V as VisitAll>::visit_opt_true_plus_minus(&mut **self, node)
+    fn fold_opt_true_plus_minus(
+        &mut self,
+        node: Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TruePlusMinus> {
+        <V as FoldAstPath>::fold_opt_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>) {
-        <V as VisitAll>::visit_opt_ts_entity_name(&mut **self, node)
+    fn fold_opt_ts_entity_name(
+        &mut self,
+        node: Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsEntityName> {
+        <V as FoldAstPath>::fold_opt_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>) {
-        <V as VisitAll>::visit_opt_ts_namespace_body(&mut **self, node)
+    fn fold_opt_ts_namespace_body(
+        &mut self,
+        node: Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsNamespaceBody> {
+        <V as FoldAstPath>::fold_opt_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>) {
-        <V as VisitAll>::visit_opt_ts_type(&mut **self, node)
+    fn fold_opt_ts_type(
+        &mut self,
+        node: Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsType>> {
+        <V as FoldAstPath>::fold_opt_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>) {
-        <V as VisitAll>::visit_opt_ts_type_ann(&mut **self, node)
+    fn fold_opt_ts_type_ann(
+        &mut self,
+        node: Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeAnn>> {
+        <V as FoldAstPath>::fold_opt_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_decl(&mut self, node: &Option<Box<TsTypeParamDecl>>) {
-        <V as VisitAll>::visit_opt_ts_type_param_decl(&mut **self, node)
+    fn fold_opt_ts_type_param_decl(
+        &mut self,
+        node: Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamDecl>> {
+        <V as FoldAstPath>::fold_opt_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_instantiation(
+    fn fold_opt_ts_type_param_instantiation(
         &mut self,
-        node: &Option<Box<TsTypeParamInstantiation>>,
-    ) {
-        <V as VisitAll>::visit_opt_ts_type_param_instantiation(&mut **self, node)
+        node: Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamInstantiation>> {
+        <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>) {
-        <V as VisitAll>::visit_opt_var_decl_or_expr(&mut **self, node)
+    fn fold_opt_var_decl_or_expr(
+        &mut self,
+        node: Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<VarDeclOrExpr> {
+        <V as FoldAstPath>::fold_opt_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>]) {
-        <V as VisitAll>::visit_opt_vec_expr_or_spreads(&mut **self, node)
+    fn fold_opt_vec_expr_or_spreads(
+        &mut self,
+        node: Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<ExprOrSpread>> {
+        <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>]) {
-        <V as VisitAll>::visit_opt_vec_pats(&mut **self, node)
+    fn fold_opt_vec_pats(
+        &mut self,
+        node: Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<Pat>> {
+        <V as FoldAstPath>::fold_opt_vec_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_param(&mut self, node: &Param) {
-        <V as VisitAll>::visit_param(&mut **self, node)
+    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
+        <V as FoldAstPath>::fold_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp) {
-        <V as VisitAll>::visit_param_or_ts_param_prop(&mut **self, node)
+    fn fold_param_or_ts_param_prop(
+        &mut self,
+        node: ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ParamOrTsParamProp {
+        <V as FoldAstPath>::fold_param_or_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp]) {
-        <V as VisitAll>::visit_param_or_ts_param_props(&mut **self, node)
+    fn fold_param_or_ts_param_props(
+        &mut self,
+        node: Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ParamOrTsParamProp> {
+        <V as FoldAstPath>::fold_param_or_ts_param_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_params(&mut self, node: &[Param]) {
-        <V as VisitAll>::visit_params(&mut **self, node)
+    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
+        <V as FoldAstPath>::fold_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_paren_expr(&mut self, node: &ParenExpr) {
-        <V as VisitAll>::visit_paren_expr(&mut **self, node)
+    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
+        <V as FoldAstPath>::fold_paren_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pat(&mut self, node: &Pat) {
-        <V as VisitAll>::visit_pat(&mut **self, node)
+    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
+        <V as FoldAstPath>::fold_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pats(&mut self, node: &[Pat]) {
-        <V as VisitAll>::visit_pats(&mut **self, node)
+    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
+        <V as FoldAstPath>::fold_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_private_method(&mut self, node: &PrivateMethod) {
-        <V as VisitAll>::visit_private_method(&mut **self, node)
+    fn fold_private_method(
+        &mut self,
+        node: PrivateMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateMethod {
+        <V as FoldAstPath>::fold_private_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_private_name(&mut self, node: &PrivateName) {
-        <V as VisitAll>::visit_private_name(&mut **self, node)
+    fn fold_private_name(
+        &mut self,
+        node: PrivateName,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateName {
+        <V as FoldAstPath>::fold_private_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_private_prop(&mut self, node: &PrivateProp) {
-        <V as VisitAll>::visit_private_prop(&mut **self, node)
+    fn fold_private_prop(
+        &mut self,
+        node: PrivateProp,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateProp {
+        <V as FoldAstPath>::fold_private_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_program(&mut self, node: &Program) {
-        <V as VisitAll>::visit_program(&mut **self, node)
+    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
+        <V as FoldAstPath>::fold_program(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop(&mut self, node: &Prop) {
-        <V as VisitAll>::visit_prop(&mut **self, node)
+    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
+        <V as FoldAstPath>::fold_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop_name(&mut self, node: &PropName) {
-        <V as VisitAll>::visit_prop_name(&mut **self, node)
+    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
+        <V as FoldAstPath>::fold_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
-        <V as VisitAll>::visit_prop_or_spread(&mut **self, node)
+    fn fold_prop_or_spread(
+        &mut self,
+        node: PropOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> PropOrSpread {
+        <V as FoldAstPath>::fold_prop_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
-        <V as VisitAll>::visit_prop_or_spreads(&mut **self, node)
+    fn fold_prop_or_spreads(
+        &mut self,
+        node: Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PropOrSpread> {
+        <V as FoldAstPath>::fold_prop_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_regex(&mut self, node: &Regex) {
-        <V as VisitAll>::visit_regex(&mut **self, node)
+    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
+        <V as FoldAstPath>::fold_regex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_rest_pat(&mut self, node: &RestPat) {
-        <V as VisitAll>::visit_rest_pat(&mut **self, node)
+    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
+        <V as FoldAstPath>::fold_rest_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_return_stmt(&mut self, node: &ReturnStmt) {
-        <V as VisitAll>::visit_return_stmt(&mut **self, node)
+    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
+        <V as FoldAstPath>::fold_return_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_script(&mut self, node: &Script) {
-        <V as VisitAll>::visit_script(&mut **self, node)
+    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
+        <V as FoldAstPath>::fold_script(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_seq_expr(&mut self, node: &SeqExpr) {
-        <V as VisitAll>::visit_seq_expr(&mut **self, node)
+    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
+        <V as FoldAstPath>::fold_seq_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_setter_prop(&mut self, node: &SetterProp) {
-        <V as VisitAll>::visit_setter_prop(&mut **self, node)
+    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
+        <V as FoldAstPath>::fold_setter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
-        <V as VisitAll>::visit_simple_assign_target(&mut **self, node)
+    fn fold_simple_assign_target(
+        &mut self,
+        node: SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleAssignTarget {
+        <V as FoldAstPath>::fold_simple_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
+        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_spread_element(&mut self, node: &SpreadElement) {
-        <V as VisitAll>::visit_spread_element(&mut **self, node)
+    fn fold_spread_element(
+        &mut self,
+        node: SpreadElement,
+        __ast_path: &mut AstKindPath,
+    ) -> SpreadElement {
+        <V as FoldAstPath>::fold_spread_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_static_block(&mut self, node: &StaticBlock) {
-        <V as VisitAll>::visit_static_block(&mut **self, node)
+    fn fold_static_block(
+        &mut self,
+        node: StaticBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> StaticBlock {
+        <V as FoldAstPath>::fold_static_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_stmt(&mut self, node: &Stmt) {
-        <V as VisitAll>::visit_stmt(&mut **self, node)
+    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
+        <V as FoldAstPath>::fold_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_stmts(&mut self, node: &[Stmt]) {
-        <V as VisitAll>::visit_stmts(&mut **self, node)
+    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
+        <V as FoldAstPath>::fold_stmts(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <V as VisitAll>::visit_str(&mut **self, node)
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_super(&mut self, node: &Super) {
-        <V as VisitAll>::visit_super(&mut **self, node)
+    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
+        <V as FoldAstPath>::fold_super(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_super_prop(&mut self, node: &SuperProp) {
-        <V as VisitAll>::visit_super_prop(&mut **self, node)
+    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
+        <V as FoldAstPath>::fold_super_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
-        <V as VisitAll>::visit_super_prop_expr(&mut **self, node)
+    fn fold_super_prop_expr(
+        &mut self,
+        node: SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> SuperPropExpr {
+        <V as FoldAstPath>::fold_super_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_switch_case(&mut self, node: &SwitchCase) {
-        <V as VisitAll>::visit_switch_case(&mut **self, node)
+    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
+        <V as FoldAstPath>::fold_switch_case(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
-        <V as VisitAll>::visit_switch_cases(&mut **self, node)
+    fn fold_switch_cases(
+        &mut self,
+        node: Vec<SwitchCase>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SwitchCase> {
+        <V as FoldAstPath>::fold_switch_cases(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
-        <V as VisitAll>::visit_switch_stmt(&mut **self, node)
+    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
+        <V as FoldAstPath>::fold_switch_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_syntax_context(&mut self, node: &swc_common::SyntaxContext) {
-        <V as VisitAll>::visit_syntax_context(&mut **self, node)
+    fn fold_syntax_context(
+        &mut self,
+        node: swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::SyntaxContext {
+        <V as FoldAstPath>::fold_syntax_context(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
-        <V as VisitAll>::visit_tagged_tpl(&mut **self, node)
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
+        <V as FoldAstPath>::fold_tagged_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_this_expr(&mut self, node: &ThisExpr) {
-        <V as VisitAll>::visit_this_expr(&mut **self, node)
+    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
+        <V as FoldAstPath>::fold_this_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
-        <V as VisitAll>::visit_throw_stmt(&mut **self, node)
+    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
+        <V as FoldAstPath>::fold_throw_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tpl(&mut self, node: &Tpl) {
-        <V as VisitAll>::visit_tpl(&mut **self, node)
+    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
+        <V as FoldAstPath>::fold_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tpl_element(&mut self, node: &TplElement) {
-        <V as VisitAll>::visit_tpl_element(&mut **self, node)
+    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
+        <V as FoldAstPath>::fold_tpl_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tpl_elements(&mut self, node: &[TplElement]) {
-        <V as VisitAll>::visit_tpl_elements(&mut **self, node)
+    fn fold_tpl_elements(
+        &mut self,
+        node: Vec<TplElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TplElement> {
+        <V as FoldAstPath>::fold_tpl_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
-        <V as VisitAll>::visit_true_plus_minus(&mut **self, node)
+    fn fold_true_plus_minus(
+        &mut self,
+        node: TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) -> TruePlusMinus {
+        <V as FoldAstPath>::fold_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_try_stmt(&mut self, node: &TryStmt) {
-        <V as VisitAll>::visit_try_stmt(&mut **self, node)
+    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
+        <V as FoldAstPath>::fold_try_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_array_type(&mut self, node: &TsArrayType) {
-        <V as VisitAll>::visit_ts_array_type(&mut **self, node)
+    fn fold_ts_array_type(
+        &mut self,
+        node: TsArrayType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsArrayType {
+        <V as FoldAstPath>::fold_ts_array_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
-        <V as VisitAll>::visit_ts_as_expr(&mut **self, node)
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
+        <V as FoldAstPath>::fold_ts_as_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
-        <V as VisitAll>::visit_ts_call_signature_decl(&mut **self, node)
+    fn fold_ts_call_signature_decl(
+        &mut self,
+        node: TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsCallSignatureDecl {
+        <V as FoldAstPath>::fold_ts_call_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
-        <V as VisitAll>::visit_ts_conditional_type(&mut **self, node)
+    fn fold_ts_conditional_type(
+        &mut self,
+        node: TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConditionalType {
+        <V as FoldAstPath>::fold_ts_conditional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
-        <V as VisitAll>::visit_ts_const_assertion(&mut **self, node)
+    fn fold_ts_const_assertion(
+        &mut self,
+        node: TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstAssertion {
+        <V as FoldAstPath>::fold_ts_const_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
-        <V as VisitAll>::visit_ts_construct_signature_decl(&mut **self, node)
+    fn fold_ts_construct_signature_decl(
+        &mut self,
+        node: TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructSignatureDecl {
+        <V as FoldAstPath>::fold_ts_construct_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
-        <V as VisitAll>::visit_ts_constructor_type(&mut **self, node)
+    fn fold_ts_constructor_type(
+        &mut self,
+        node: TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructorType {
+        <V as FoldAstPath>::fold_ts_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
-        <V as VisitAll>::visit_ts_entity_name(&mut **self, node)
+    fn fold_ts_entity_name(
+        &mut self,
+        node: TsEntityName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEntityName {
+        <V as FoldAstPath>::fold_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
-        <V as VisitAll>::visit_ts_enum_decl(&mut **self, node)
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
+        <V as FoldAstPath>::fold_ts_enum_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
-        <V as VisitAll>::visit_ts_enum_member(&mut **self, node)
+    fn fold_ts_enum_member(
+        &mut self,
+        node: TsEnumMember,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMember {
+        <V as FoldAstPath>::fold_ts_enum_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
-        <V as VisitAll>::visit_ts_enum_member_id(&mut **self, node)
+    fn fold_ts_enum_member_id(
+        &mut self,
+        node: TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMemberId {
+        <V as FoldAstPath>::fold_ts_enum_member_id(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
-        <V as VisitAll>::visit_ts_enum_members(&mut **self, node)
+    fn fold_ts_enum_members(
+        &mut self,
+        node: Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsEnumMember> {
+        <V as FoldAstPath>::fold_ts_enum_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
-        <V as VisitAll>::visit_ts_export_assignment(&mut **self, node)
+    fn fold_ts_export_assignment(
+        &mut self,
+        node: TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExportAssignment {
+        <V as FoldAstPath>::fold_ts_export_assignment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs) {
-        <V as VisitAll>::visit_ts_expr_with_type_args(&mut **self, node)
+    fn fold_ts_expr_with_type_args(
+        &mut self,
+        node: TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExprWithTypeArgs {
+        <V as FoldAstPath>::fold_ts_expr_with_type_args(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs]) {
-        <V as VisitAll>::visit_ts_expr_with_type_argss(&mut **self, node)
+    fn fold_ts_expr_with_type_argss(
+        &mut self,
+        node: Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsExprWithTypeArgs> {
+        <V as FoldAstPath>::fold_ts_expr_with_type_argss(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
-        <V as VisitAll>::visit_ts_external_module_ref(&mut **self, node)
+    fn fold_ts_external_module_ref(
+        &mut self,
+        node: TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExternalModuleRef {
+        <V as FoldAstPath>::fold_ts_external_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType) {
-        <V as VisitAll>::visit_ts_fn_or_constructor_type(&mut **self, node)
+    fn fold_ts_fn_or_constructor_type(
+        &mut self,
+        node: TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsFnOrConstructorType {
+        <V as FoldAstPath>::fold_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
-        <V as VisitAll>::visit_ts_fn_param(&mut **self, node)
+    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
+        <V as FoldAstPath>::fold_ts_fn_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
-        <V as VisitAll>::visit_ts_fn_params(&mut **self, node)
+    fn fold_ts_fn_params(
+        &mut self,
+        node: Vec<TsFnParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsFnParam> {
+        <V as FoldAstPath>::fold_ts_fn_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_type(&mut self, node: &TsFnType) {
-        <V as VisitAll>::visit_ts_fn_type(&mut **self, node)
+    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
+        <V as FoldAstPath>::fold_ts_fn_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
-        <V as VisitAll>::visit_ts_getter_signature(&mut **self, node)
+    fn fold_ts_getter_signature(
+        &mut self,
+        node: TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsGetterSignature {
+        <V as FoldAstPath>::fold_ts_getter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
-        <V as VisitAll>::visit_ts_import_equals_decl(&mut **self, node)
+    fn fold_ts_import_equals_decl(
+        &mut self,
+        node: TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportEqualsDecl {
+        <V as FoldAstPath>::fold_ts_import_equals_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_import_type(&mut self, node: &TsImportType) {
-        <V as VisitAll>::visit_ts_import_type(&mut **self, node)
+    fn fold_ts_import_type(
+        &mut self,
+        node: TsImportType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportType {
+        <V as FoldAstPath>::fold_ts_import_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
-        <V as VisitAll>::visit_ts_index_signature(&mut **self, node)
+    fn fold_ts_index_signature(
+        &mut self,
+        node: TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexSignature {
+        <V as FoldAstPath>::fold_ts_index_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
-        <V as VisitAll>::visit_ts_indexed_access_type(&mut **self, node)
+    fn fold_ts_indexed_access_type(
+        &mut self,
+        node: TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexedAccessType {
+        <V as FoldAstPath>::fold_ts_indexed_access_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_infer_type(&mut self, node: &TsInferType) {
-        <V as VisitAll>::visit_ts_infer_type(&mut **self, node)
+    fn fold_ts_infer_type(
+        &mut self,
+        node: TsInferType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInferType {
+        <V as FoldAstPath>::fold_ts_infer_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
-        <V as VisitAll>::visit_ts_instantiation(&mut **self, node)
+    fn fold_ts_instantiation(
+        &mut self,
+        node: TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInstantiation {
+        <V as FoldAstPath>::fold_ts_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
-        <V as VisitAll>::visit_ts_interface_body(&mut **self, node)
+    fn fold_ts_interface_body(
+        &mut self,
+        node: TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceBody {
+        <V as FoldAstPath>::fold_ts_interface_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
-        <V as VisitAll>::visit_ts_interface_decl(&mut **self, node)
+    fn fold_ts_interface_decl(
+        &mut self,
+        node: TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceDecl {
+        <V as FoldAstPath>::fold_ts_interface_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
-        <V as VisitAll>::visit_ts_intersection_type(&mut **self, node)
+    fn fold_ts_intersection_type(
+        &mut self,
+        node: TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIntersectionType {
+        <V as FoldAstPath>::fold_ts_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
-        <V as VisitAll>::visit_ts_keyword_type(&mut **self, node)
+    fn fold_ts_keyword_type(
+        &mut self,
+        node: TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordType {
+        <V as FoldAstPath>::fold_ts_keyword_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
-        <V as VisitAll>::visit_ts_keyword_type_kind(&mut **self, node)
+    fn fold_ts_keyword_type_kind(
+        &mut self,
+        node: TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordTypeKind {
+        <V as FoldAstPath>::fold_ts_keyword_type_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_lit(&mut self, node: &TsLit) {
-        <V as VisitAll>::visit_ts_lit(&mut **self, node)
+    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
+        <V as FoldAstPath>::fold_ts_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_lit_type(&mut self, node: &TsLitType) {
-        <V as VisitAll>::visit_ts_lit_type(&mut **self, node)
+    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
+        <V as FoldAstPath>::fold_ts_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
-        <V as VisitAll>::visit_ts_mapped_type(&mut **self, node)
+    fn fold_ts_mapped_type(
+        &mut self,
+        node: TsMappedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMappedType {
+        <V as FoldAstPath>::fold_ts_mapped_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
-        <V as VisitAll>::visit_ts_method_signature(&mut **self, node)
+    fn fold_ts_method_signature(
+        &mut self,
+        node: TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMethodSignature {
+        <V as FoldAstPath>::fold_ts_method_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
-        <V as VisitAll>::visit_ts_module_block(&mut **self, node)
+    fn fold_ts_module_block(
+        &mut self,
+        node: TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleBlock {
+        <V as FoldAstPath>::fold_ts_module_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
-        <V as VisitAll>::visit_ts_module_decl(&mut **self, node)
+    fn fold_ts_module_decl(
+        &mut self,
+        node: TsModuleDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleDecl {
+        <V as FoldAstPath>::fold_ts_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_name(&mut self, node: &TsModuleName) {
-        <V as VisitAll>::visit_ts_module_name(&mut **self, node)
+    fn fold_ts_module_name(
+        &mut self,
+        node: TsModuleName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleName {
+        <V as FoldAstPath>::fold_ts_module_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
-        <V as VisitAll>::visit_ts_module_ref(&mut **self, node)
+    fn fold_ts_module_ref(
+        &mut self,
+        node: TsModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleRef {
+        <V as FoldAstPath>::fold_ts_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
-        <V as VisitAll>::visit_ts_namespace_body(&mut **self, node)
+    fn fold_ts_namespace_body(
+        &mut self,
+        node: TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceBody {
+        <V as FoldAstPath>::fold_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
-        <V as VisitAll>::visit_ts_namespace_decl(&mut **self, node)
+    fn fold_ts_namespace_decl(
+        &mut self,
+        node: TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceDecl {
+        <V as FoldAstPath>::fold_ts_namespace_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
-        <V as VisitAll>::visit_ts_namespace_export_decl(&mut **self, node)
+    fn fold_ts_namespace_export_decl(
+        &mut self,
+        node: TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceExportDecl {
+        <V as FoldAstPath>::fold_ts_namespace_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
-        <V as VisitAll>::visit_ts_non_null_expr(&mut **self, node)
+    fn fold_ts_non_null_expr(
+        &mut self,
+        node: TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNonNullExpr {
+        <V as FoldAstPath>::fold_ts_non_null_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
-        <V as VisitAll>::visit_ts_optional_type(&mut **self, node)
+    fn fold_ts_optional_type(
+        &mut self,
+        node: TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsOptionalType {
+        <V as FoldAstPath>::fold_ts_optional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
-        <V as VisitAll>::visit_ts_param_prop(&mut **self, node)
+    fn fold_ts_param_prop(
+        &mut self,
+        node: TsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamProp {
+        <V as FoldAstPath>::fold_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
-        <V as VisitAll>::visit_ts_param_prop_param(&mut **self, node)
+    fn fold_ts_param_prop_param(
+        &mut self,
+        node: TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamPropParam {
+        <V as FoldAstPath>::fold_ts_param_prop_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
-        <V as VisitAll>::visit_ts_parenthesized_type(&mut **self, node)
+    fn fold_ts_parenthesized_type(
+        &mut self,
+        node: TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParenthesizedType {
+        <V as FoldAstPath>::fold_ts_parenthesized_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
-        <V as VisitAll>::visit_ts_property_signature(&mut **self, node)
+    fn fold_ts_property_signature(
+        &mut self,
+        node: TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsPropertySignature {
+        <V as FoldAstPath>::fold_ts_property_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
-        <V as VisitAll>::visit_ts_qualified_name(&mut **self, node)
+    fn fold_ts_qualified_name(
+        &mut self,
+        node: TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsQualifiedName {
+        <V as FoldAstPath>::fold_ts_qualified_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_rest_type(&mut self, node: &TsRestType) {
-        <V as VisitAll>::visit_ts_rest_type(&mut **self, node)
+    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
+        <V as FoldAstPath>::fold_ts_rest_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
-        <V as VisitAll>::visit_ts_satisfies_expr(&mut **self, node)
+    fn fold_ts_satisfies_expr(
+        &mut self,
+        node: TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSatisfiesExpr {
+        <V as FoldAstPath>::fold_ts_satisfies_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
-        <V as VisitAll>::visit_ts_setter_signature(&mut **self, node)
+    fn fold_ts_setter_signature(
+        &mut self,
+        node: TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSetterSignature {
+        <V as FoldAstPath>::fold_ts_setter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_this_type(&mut self, node: &TsThisType) {
-        <V as VisitAll>::visit_ts_this_type(&mut **self, node)
+    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
+        <V as FoldAstPath>::fold_ts_this_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent) {
-        <V as VisitAll>::visit_ts_this_type_or_ident(&mut **self, node)
+    fn fold_ts_this_type_or_ident(
+        &mut self,
+        node: TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> TsThisTypeOrIdent {
+        <V as FoldAstPath>::fold_ts_this_type_or_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
-        <V as VisitAll>::visit_ts_tpl_lit_type(&mut **self, node)
+    fn fold_ts_tpl_lit_type(
+        &mut self,
+        node: TsTplLitType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTplLitType {
+        <V as FoldAstPath>::fold_ts_tpl_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
-        <V as VisitAll>::visit_ts_tuple_element(&mut **self, node)
+    fn fold_ts_tuple_element(
+        &mut self,
+        node: TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleElement {
+        <V as FoldAstPath>::fold_ts_tuple_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
-        <V as VisitAll>::visit_ts_tuple_elements(&mut **self, node)
+    fn fold_ts_tuple_elements(
+        &mut self,
+        node: Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTupleElement> {
+        <V as FoldAstPath>::fold_ts_tuple_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
-        <V as VisitAll>::visit_ts_tuple_type(&mut **self, node)
+    fn fold_ts_tuple_type(
+        &mut self,
+        node: TsTupleType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleType {
+        <V as FoldAstPath>::fold_ts_tuple_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type(&mut self, node: &TsType) {
-        <V as VisitAll>::visit_ts_type(&mut **self, node)
+    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
+        <V as FoldAstPath>::fold_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
-        <V as VisitAll>::visit_ts_type_alias_decl(&mut **self, node)
+    fn fold_ts_type_alias_decl(
+        &mut self,
+        node: TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAliasDecl {
+        <V as FoldAstPath>::fold_ts_type_alias_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
-        <V as VisitAll>::visit_ts_type_ann(&mut **self, node)
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
+        <V as FoldAstPath>::fold_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
-        <V as VisitAll>::visit_ts_type_assertion(&mut **self, node)
+    fn fold_ts_type_assertion(
+        &mut self,
+        node: TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAssertion {
+        <V as FoldAstPath>::fold_ts_type_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
-        <V as VisitAll>::visit_ts_type_element(&mut **self, node)
+    fn fold_ts_type_element(
+        &mut self,
+        node: TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeElement {
+        <V as FoldAstPath>::fold_ts_type_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
-        <V as VisitAll>::visit_ts_type_elements(&mut **self, node)
+    fn fold_ts_type_elements(
+        &mut self,
+        node: Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeElement> {
+        <V as FoldAstPath>::fold_ts_type_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
-        <V as VisitAll>::visit_ts_type_lit(&mut **self, node)
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
+        <V as FoldAstPath>::fold_ts_type_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
-        <V as VisitAll>::visit_ts_type_operator(&mut **self, node)
+    fn fold_ts_type_operator(
+        &mut self,
+        node: TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperator {
+        <V as FoldAstPath>::fold_ts_type_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
-        <V as VisitAll>::visit_ts_type_operator_op(&mut **self, node)
+    fn fold_ts_type_operator_op(
+        &mut self,
+        node: TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperatorOp {
+        <V as FoldAstPath>::fold_ts_type_operator_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
-        <V as VisitAll>::visit_ts_type_param(&mut **self, node)
+    fn fold_ts_type_param(
+        &mut self,
+        node: TsTypeParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParam {
+        <V as FoldAstPath>::fold_ts_type_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
-        <V as VisitAll>::visit_ts_type_param_decl(&mut **self, node)
+    fn fold_ts_type_param_decl(
+        &mut self,
+        node: TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamDecl {
+        <V as FoldAstPath>::fold_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
-        <V as VisitAll>::visit_ts_type_param_instantiation(&mut **self, node)
+    fn fold_ts_type_param_instantiation(
+        &mut self,
+        node: TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamInstantiation {
+        <V as FoldAstPath>::fold_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
-        <V as VisitAll>::visit_ts_type_params(&mut **self, node)
+    fn fold_ts_type_params(
+        &mut self,
+        node: Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeParam> {
+        <V as FoldAstPath>::fold_ts_type_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
-        <V as VisitAll>::visit_ts_type_predicate(&mut **self, node)
+    fn fold_ts_type_predicate(
+        &mut self,
+        node: TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypePredicate {
+        <V as FoldAstPath>::fold_ts_type_predicate(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
-        <V as VisitAll>::visit_ts_type_query(&mut **self, node)
+    fn fold_ts_type_query(
+        &mut self,
+        node: TsTypeQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQuery {
+        <V as FoldAstPath>::fold_ts_type_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
-        <V as VisitAll>::visit_ts_type_query_expr(&mut **self, node)
+    fn fold_ts_type_query_expr(
+        &mut self,
+        node: TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQueryExpr {
+        <V as FoldAstPath>::fold_ts_type_query_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
-        <V as VisitAll>::visit_ts_type_ref(&mut **self, node)
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
+        <V as FoldAstPath>::fold_ts_type_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
-        <V as VisitAll>::visit_ts_types(&mut **self, node)
+    fn fold_ts_types(
+        &mut self,
+        node: Vec<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Box<TsType>> {
+        <V as FoldAstPath>::fold_ts_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_union_or_intersection_type(&mut self, node: &TsUnionOrIntersectionType) {
-        <V as VisitAll>::visit_ts_union_or_intersection_type(&mut **self, node)
+    fn fold_ts_union_or_intersection_type(
+        &mut self,
+        node: TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionOrIntersectionType {
+        <V as FoldAstPath>::fold_ts_union_or_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_union_type(&mut self, node: &TsUnionType) {
-        <V as VisitAll>::visit_ts_union_type(&mut **self, node)
+    fn fold_ts_union_type(
+        &mut self,
+        node: TsUnionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionType {
+        <V as FoldAstPath>::fold_ts_union_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_unary_expr(&mut self, node: &UnaryExpr) {
-        <V as VisitAll>::visit_unary_expr(&mut **self, node)
+    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
+        <V as FoldAstPath>::fold_unary_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_unary_op(&mut self, node: &UnaryOp) {
-        <V as VisitAll>::visit_unary_op(&mut **self, node)
+    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
+        <V as FoldAstPath>::fold_unary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_update_expr(&mut self, node: &UpdateExpr) {
-        <V as VisitAll>::visit_update_expr(&mut **self, node)
+    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
+        <V as FoldAstPath>::fold_update_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_update_op(&mut self, node: &UpdateOp) {
-        <V as VisitAll>::visit_update_op(&mut **self, node)
+    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
+        <V as FoldAstPath>::fold_update_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_using_decl(&mut self, node: &UsingDecl) {
-        <V as VisitAll>::visit_using_decl(&mut **self, node)
+    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
+        <V as FoldAstPath>::fold_using_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_decl(&mut self, node: &VarDecl) {
-        <V as VisitAll>::visit_var_decl(&mut **self, node)
+    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
+        <V as FoldAstPath>::fold_var_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
-        <V as VisitAll>::visit_var_decl_kind(&mut **self, node)
+    fn fold_var_decl_kind(
+        &mut self,
+        node: VarDeclKind,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclKind {
+        <V as FoldAstPath>::fold_var_decl_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
-        <V as VisitAll>::visit_var_decl_or_expr(&mut **self, node)
+    fn fold_var_decl_or_expr(
+        &mut self,
+        node: VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclOrExpr {
+        <V as FoldAstPath>::fold_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_declarator(&mut self, node: &VarDeclarator) {
-        <V as VisitAll>::visit_var_declarator(&mut **self, node)
+    fn fold_var_declarator(
+        &mut self,
+        node: VarDeclarator,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclarator {
+        <V as FoldAstPath>::fold_var_declarator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
-        <V as VisitAll>::visit_var_declarators(&mut **self, node)
+    fn fold_var_declarators(
+        &mut self,
+        node: Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<VarDeclarator> {
+        <V as FoldAstPath>::fold_var_declarators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_while_stmt(&mut self, node: &WhileStmt) {
-        <V as VisitAll>::visit_while_stmt(&mut **self, node)
+    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
+        <V as FoldAstPath>::fold_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_with_stmt(&mut self, node: &WithStmt) {
-        <V as VisitAll>::visit_with_stmt(&mut **self, node)
+    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
+        <V as FoldAstPath>::fold_with_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_yield_expr(&mut self, node: &YieldExpr) {
-        <V as VisitAll>::visit_yield_expr(&mut **self, node)
+    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
+        <V as FoldAstPath>::fold_yield_expr(&mut **self, node, __ast_path)
     }
 }
-impl<V> VisitAll for Box<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> FoldAstPath for Box<V>
 where
-    V: ?Sized + VisitAll,
+    V: ?Sized + FoldAstPath,
 {
     #[inline]
-    fn visit_accessibility(&mut self, node: &Accessibility) {
-        <V as VisitAll>::visit_accessibility(&mut **self, node)
+    fn fold_accessibility(
+        &mut self,
+        node: Accessibility,
+        __ast_path: &mut AstKindPath,
+    ) -> Accessibility {
+        <V as FoldAstPath>::fold_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_array_lit(&mut self, node: &ArrayLit) {
-        <V as VisitAll>::visit_array_lit(&mut **self, node)
+    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
+        <V as FoldAstPath>::fold_array_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_array_pat(&mut self, node: &ArrayPat) {
-        <V as VisitAll>::visit_array_pat(&mut **self, node)
+    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
+        <V as FoldAstPath>::fold_array_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
-        <V as VisitAll>::visit_arrow_expr(&mut **self, node)
+    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
+        <V as FoldAstPath>::fold_arrow_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_expr(&mut self, node: &AssignExpr) {
-        <V as VisitAll>::visit_assign_expr(&mut **self, node)
+    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
+        <V as FoldAstPath>::fold_assign_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_op(&mut self, node: &AssignOp) {
-        <V as VisitAll>::visit_assign_op(&mut **self, node)
+    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
+        <V as FoldAstPath>::fold_assign_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_pat(&mut self, node: &AssignPat) {
-        <V as VisitAll>::visit_assign_pat(&mut **self, node)
+    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
+        <V as FoldAstPath>::fold_assign_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
-        <V as VisitAll>::visit_assign_pat_prop(&mut **self, node)
+    fn fold_assign_pat_prop(
+        &mut self,
+        node: AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignPatProp {
+        <V as FoldAstPath>::fold_assign_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_prop(&mut self, node: &AssignProp) {
-        <V as VisitAll>::visit_assign_prop(&mut **self, node)
+    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
+        <V as FoldAstPath>::fold_assign_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_target(&mut self, node: &AssignTarget) {
-        <V as VisitAll>::visit_assign_target(&mut **self, node)
+    fn fold_assign_target(
+        &mut self,
+        node: AssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTarget {
+        <V as FoldAstPath>::fold_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
-        <V as VisitAll>::visit_assign_target_pat(&mut **self, node)
+    fn fold_assign_target_pat(
+        &mut self,
+        node: AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTargetPat {
+        <V as FoldAstPath>::fold_assign_target_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
+        <V as FoldAstPath>::fold_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
-        <V as VisitAll>::visit_auto_accessor(&mut **self, node)
+    fn fold_auto_accessor(
+        &mut self,
+        node: AutoAccessor,
+        __ast_path: &mut AstKindPath,
+    ) -> AutoAccessor {
+        <V as FoldAstPath>::fold_auto_accessor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_await_expr(&mut self, node: &AwaitExpr) {
-        <V as VisitAll>::visit_await_expr(&mut **self, node)
+    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
+        <V as FoldAstPath>::fold_await_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_big_int(&mut self, node: &BigInt) {
-        <V as VisitAll>::visit_big_int(&mut **self, node)
+    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
+        <V as FoldAstPath>::fold_big_int(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_big_int_value(&mut self, node: &BigIntValue) {
-        <V as VisitAll>::visit_big_int_value(&mut **self, node)
+    fn fold_big_int_value(
+        &mut self,
+        node: BigIntValue,
+        __ast_path: &mut AstKindPath,
+    ) -> BigIntValue {
+        <V as FoldAstPath>::fold_big_int_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_bin_expr(&mut self, node: &BinExpr) {
-        <V as VisitAll>::visit_bin_expr(&mut **self, node)
+    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
+        <V as FoldAstPath>::fold_bin_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_binary_op(&mut self, node: &BinaryOp) {
-        <V as VisitAll>::visit_binary_op(&mut **self, node)
+    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
+        <V as FoldAstPath>::fold_binary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_binding_ident(&mut self, node: &BindingIdent) {
-        <V as VisitAll>::visit_binding_ident(&mut **self, node)
+    fn fold_binding_ident(
+        &mut self,
+        node: BindingIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> BindingIdent {
+        <V as FoldAstPath>::fold_binding_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_block_stmt(&mut self, node: &BlockStmt) {
-        <V as VisitAll>::visit_block_stmt(&mut **self, node)
+    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
+        <V as FoldAstPath>::fold_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
-        <V as VisitAll>::visit_block_stmt_or_expr(&mut **self, node)
+    fn fold_block_stmt_or_expr(
+        &mut self,
+        node: BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> BlockStmtOrExpr {
+        <V as FoldAstPath>::fold_block_stmt_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_bool(&mut self, node: &Bool) {
-        <V as VisitAll>::visit_bool(&mut **self, node)
+    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
+        <V as FoldAstPath>::fold_bool(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_break_stmt(&mut self, node: &BreakStmt) {
-        <V as VisitAll>::visit_break_stmt(&mut **self, node)
+    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
+        <V as FoldAstPath>::fold_break_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_call_expr(&mut self, node: &CallExpr) {
-        <V as VisitAll>::visit_call_expr(&mut **self, node)
+    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
+        <V as FoldAstPath>::fold_call_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_callee(&mut self, node: &Callee) {
-        <V as VisitAll>::visit_callee(&mut **self, node)
+    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
+        <V as FoldAstPath>::fold_callee(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_catch_clause(&mut self, node: &CatchClause) {
-        <V as VisitAll>::visit_catch_clause(&mut **self, node)
+    fn fold_catch_clause(
+        &mut self,
+        node: CatchClause,
+        __ast_path: &mut AstKindPath,
+    ) -> CatchClause {
+        <V as FoldAstPath>::fold_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class(&mut self, node: &Class) {
-        <V as VisitAll>::visit_class(&mut **self, node)
+    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
+        <V as FoldAstPath>::fold_class(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_decl(&mut self, node: &ClassDecl) {
-        <V as VisitAll>::visit_class_decl(&mut **self, node)
+    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
+        <V as FoldAstPath>::fold_class_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_expr(&mut self, node: &ClassExpr) {
-        <V as VisitAll>::visit_class_expr(&mut **self, node)
+    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
+        <V as FoldAstPath>::fold_class_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_member(&mut self, node: &ClassMember) {
-        <V as VisitAll>::visit_class_member(&mut **self, node)
+    fn fold_class_member(
+        &mut self,
+        node: ClassMember,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMember {
+        <V as FoldAstPath>::fold_class_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_members(&mut self, node: &[ClassMember]) {
-        <V as VisitAll>::visit_class_members(&mut **self, node)
+    fn fold_class_members(
+        &mut self,
+        node: Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ClassMember> {
+        <V as FoldAstPath>::fold_class_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_method(&mut self, node: &ClassMethod) {
-        <V as VisitAll>::visit_class_method(&mut **self, node)
+    fn fold_class_method(
+        &mut self,
+        node: ClassMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMethod {
+        <V as FoldAstPath>::fold_class_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_class_prop(&mut self, node: &ClassProp) {
-        <V as VisitAll>::visit_class_prop(&mut **self, node)
+    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
+        <V as FoldAstPath>::fold_class_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
-        <V as VisitAll>::visit_computed_prop_name(&mut **self, node)
+    fn fold_computed_prop_name(
+        &mut self,
+        node: ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) -> ComputedPropName {
+        <V as FoldAstPath>::fold_computed_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_cond_expr(&mut self, node: &CondExpr) {
-        <V as VisitAll>::visit_cond_expr(&mut **self, node)
+    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
+        <V as FoldAstPath>::fold_cond_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_constructor(&mut self, node: &Constructor) {
-        <V as VisitAll>::visit_constructor(&mut **self, node)
+    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
+        <V as FoldAstPath>::fold_constructor(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
-        <V as VisitAll>::visit_continue_stmt(&mut **self, node)
+    fn fold_continue_stmt(
+        &mut self,
+        node: ContinueStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> ContinueStmt {
+        <V as FoldAstPath>::fold_continue_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
-        <V as VisitAll>::visit_debugger_stmt(&mut **self, node)
+    fn fold_debugger_stmt(
+        &mut self,
+        node: DebuggerStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DebuggerStmt {
+        <V as FoldAstPath>::fold_debugger_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_decl(&mut self, node: &Decl) {
-        <V as VisitAll>::visit_decl(&mut **self, node)
+    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
+        <V as FoldAstPath>::fold_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_decorator(&mut self, node: &Decorator) {
-        <V as VisitAll>::visit_decorator(&mut **self, node)
+    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
+        <V as FoldAstPath>::fold_decorator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_decorators(&mut self, node: &[Decorator]) {
-        <V as VisitAll>::visit_decorators(&mut **self, node)
+    fn fold_decorators(
+        &mut self,
+        node: Vec<Decorator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Decorator> {
+        <V as FoldAstPath>::fold_decorators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_default_decl(&mut self, node: &DefaultDecl) {
-        <V as VisitAll>::visit_default_decl(&mut **self, node)
+    fn fold_default_decl(
+        &mut self,
+        node: DefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> DefaultDecl {
+        <V as FoldAstPath>::fold_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
-        <V as VisitAll>::visit_do_while_stmt(&mut **self, node)
+    fn fold_do_while_stmt(
+        &mut self,
+        node: DoWhileStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DoWhileStmt {
+        <V as FoldAstPath>::fold_do_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
-        <V as VisitAll>::visit_empty_stmt(&mut **self, node)
+    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
+        <V as FoldAstPath>::fold_empty_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_es_version(&mut self, node: &EsVersion) {
-        <V as VisitAll>::visit_es_version(&mut **self, node)
+    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
+        <V as FoldAstPath>::fold_es_version(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_all(&mut self, node: &ExportAll) {
-        <V as VisitAll>::visit_export_all(&mut **self, node)
+    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
+        <V as FoldAstPath>::fold_export_all(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_decl(&mut self, node: &ExportDecl) {
-        <V as VisitAll>::visit_export_decl(&mut **self, node)
+    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
+        <V as FoldAstPath>::fold_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
-        <V as VisitAll>::visit_export_default_decl(&mut **self, node)
+    fn fold_export_default_decl(
+        &mut self,
+        node: ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultDecl {
+        <V as FoldAstPath>::fold_export_default_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
-        <V as VisitAll>::visit_export_default_expr(&mut **self, node)
+    fn fold_export_default_expr(
+        &mut self,
+        node: ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultExpr {
+        <V as FoldAstPath>::fold_export_default_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
-        <V as VisitAll>::visit_export_default_specifier(&mut **self, node)
+    fn fold_export_default_specifier(
+        &mut self,
+        node: ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultSpecifier {
+        <V as FoldAstPath>::fold_export_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
-        <V as VisitAll>::visit_export_named_specifier(&mut **self, node)
+    fn fold_export_named_specifier(
+        &mut self,
+        node: ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamedSpecifier {
+        <V as FoldAstPath>::fold_export_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
-        <V as VisitAll>::visit_export_namespace_specifier(&mut **self, node)
+    fn fold_export_namespace_specifier(
+        &mut self,
+        node: ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamespaceSpecifier {
+        <V as FoldAstPath>::fold_export_namespace_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
-        <V as VisitAll>::visit_export_specifier(&mut **self, node)
+    fn fold_export_specifier(
+        &mut self,
+        node: ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportSpecifier {
+        <V as FoldAstPath>::fold_export_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
-        <V as VisitAll>::visit_export_specifiers(&mut **self, node)
+    fn fold_export_specifiers(
+        &mut self,
+        node: Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExportSpecifier> {
+        <V as FoldAstPath>::fold_export_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr(&mut self, node: &Expr) {
-        <V as VisitAll>::visit_expr(&mut **self, node)
+    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
+        <V as FoldAstPath>::fold_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
-        <V as VisitAll>::visit_expr_or_spread(&mut **self, node)
+    fn fold_expr_or_spread(
+        &mut self,
+        node: ExprOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> ExprOrSpread {
+        <V as FoldAstPath>::fold_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
-        <V as VisitAll>::visit_expr_or_spreads(&mut **self, node)
+    fn fold_expr_or_spreads(
+        &mut self,
+        node: Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExprOrSpread> {
+        <V as FoldAstPath>::fold_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_expr_stmt(&mut self, node: &ExprStmt) {
-        <V as VisitAll>::visit_expr_stmt(&mut **self, node)
+    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
+        <V as FoldAstPath>::fold_expr_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_exprs(&mut self, node: &[Box<Expr>]) {
-        <V as VisitAll>::visit_exprs(&mut **self, node)
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
+        <V as FoldAstPath>::fold_exprs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_fn_decl(&mut self, node: &FnDecl) {
-        <V as VisitAll>::visit_fn_decl(&mut **self, node)
+    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
+        <V as FoldAstPath>::fold_fn_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_fn_expr(&mut self, node: &FnExpr) {
-        <V as VisitAll>::visit_fn_expr(&mut **self, node)
+    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
+        <V as FoldAstPath>::fold_fn_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_head(&mut self, node: &ForHead) {
-        <V as VisitAll>::visit_for_head(&mut **self, node)
+    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
+        <V as FoldAstPath>::fold_for_head(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
-        <V as VisitAll>::visit_for_in_stmt(&mut **self, node)
+    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
+        <V as FoldAstPath>::fold_for_in_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
-        <V as VisitAll>::visit_for_of_stmt(&mut **self, node)
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
+        <V as FoldAstPath>::fold_for_of_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_for_stmt(&mut self, node: &ForStmt) {
-        <V as VisitAll>::visit_for_stmt(&mut **self, node)
+    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
+        <V as FoldAstPath>::fold_for_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
-        <V as VisitAll>::visit_function(&mut **self, node)
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
+        <V as FoldAstPath>::fold_function(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_getter_prop(&mut self, node: &GetterProp) {
-        <V as VisitAll>::visit_getter_prop(&mut **self, node)
+    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
+        <V as FoldAstPath>::fold_getter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
-        <V as VisitAll>::visit_ident(&mut **self, node)
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
+        <V as FoldAstPath>::fold_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ident_name(&mut self, node: &IdentName) {
-        <V as VisitAll>::visit_ident_name(&mut **self, node)
+    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
+        <V as FoldAstPath>::fold_ident_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_if_stmt(&mut self, node: &IfStmt) {
-        <V as VisitAll>::visit_if_stmt(&mut **self, node)
+    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
+        <V as FoldAstPath>::fold_if_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import(&mut self, node: &Import) {
-        <V as VisitAll>::visit_import(&mut **self, node)
+    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
+        <V as FoldAstPath>::fold_import(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_decl(&mut self, node: &ImportDecl) {
-        <V as VisitAll>::visit_import_decl(&mut **self, node)
+    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
+        <V as FoldAstPath>::fold_import_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
-        <V as VisitAll>::visit_import_default_specifier(&mut **self, node)
+    fn fold_import_default_specifier(
+        &mut self,
+        node: ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportDefaultSpecifier {
+        <V as FoldAstPath>::fold_import_default_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
-        <V as VisitAll>::visit_import_named_specifier(&mut **self, node)
+    fn fold_import_named_specifier(
+        &mut self,
+        node: ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportNamedSpecifier {
+        <V as FoldAstPath>::fold_import_named_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_phase(&mut self, node: &ImportPhase) {
-        <V as VisitAll>::visit_import_phase(&mut **self, node)
+    fn fold_import_phase(
+        &mut self,
+        node: ImportPhase,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPhase {
+        <V as FoldAstPath>::fold_import_phase(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
-        <V as VisitAll>::visit_import_specifier(&mut **self, node)
+    fn fold_import_specifier(
+        &mut self,
+        node: ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportSpecifier {
+        <V as FoldAstPath>::fold_import_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
-        <V as VisitAll>::visit_import_specifiers(&mut **self, node)
+    fn fold_import_specifiers(
+        &mut self,
+        node: Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportSpecifier> {
+        <V as FoldAstPath>::fold_import_specifiers(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
-        <V as VisitAll>::visit_import_star_as_specifier(&mut **self, node)
+    fn fold_import_star_as_specifier(
+        &mut self,
+        node: ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportStarAsSpecifier {
+        <V as FoldAstPath>::fold_import_star_as_specifier(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_with(&mut self, node: &ImportWith) {
-        <V as VisitAll>::visit_import_with(&mut **self, node)
+    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
+        <V as FoldAstPath>::fold_import_with(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_with_item(&mut self, node: &ImportWithItem) {
-        <V as VisitAll>::visit_import_with_item(&mut **self, node)
+    fn fold_import_with_item(
+        &mut self,
+        node: ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportWithItem {
+        <V as FoldAstPath>::fold_import_with_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
-        <V as VisitAll>::visit_import_with_items(&mut **self, node)
+    fn fold_import_with_items(
+        &mut self,
+        node: Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportWithItem> {
+        <V as FoldAstPath>::fold_import_with_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_invalid(&mut self, node: &Invalid) {
-        <V as VisitAll>::visit_invalid(&mut **self, node)
+    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
+        <V as FoldAstPath>::fold_invalid(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr(&mut self, node: &JSXAttr) {
-        <V as VisitAll>::visit_jsx_attr(&mut **self, node)
+    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
+        <V as FoldAstPath>::fold_jsx_attr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
-        <V as VisitAll>::visit_jsx_attr_name(&mut **self, node)
+    fn fold_jsx_attr_name(
+        &mut self,
+        node: JSXAttrName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrName {
+        <V as FoldAstPath>::fold_jsx_attr_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
-        <V as VisitAll>::visit_jsx_attr_or_spread(&mut **self, node)
+    fn fold_jsx_attr_or_spread(
+        &mut self,
+        node: JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrOrSpread {
+        <V as FoldAstPath>::fold_jsx_attr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
-        <V as VisitAll>::visit_jsx_attr_or_spreads(&mut **self, node)
+    fn fold_jsx_attr_or_spreads(
+        &mut self,
+        node: Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXAttrOrSpread> {
+        <V as FoldAstPath>::fold_jsx_attr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
-        <V as VisitAll>::visit_jsx_attr_value(&mut **self, node)
+    fn fold_jsx_attr_value(
+        &mut self,
+        node: JSXAttrValue,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrValue {
+        <V as FoldAstPath>::fold_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
-        <V as VisitAll>::visit_jsx_closing_element(&mut **self, node)
+    fn fold_jsx_closing_element(
+        &mut self,
+        node: JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingElement {
+        <V as FoldAstPath>::fold_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
-        <V as VisitAll>::visit_jsx_closing_fragment(&mut **self, node)
+    fn fold_jsx_closing_fragment(
+        &mut self,
+        node: JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingFragment {
+        <V as FoldAstPath>::fold_jsx_closing_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element(&mut self, node: &JSXElement) {
-        <V as VisitAll>::visit_jsx_element(&mut **self, node)
+    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
+        <V as FoldAstPath>::fold_jsx_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
-        <V as VisitAll>::visit_jsx_element_child(&mut **self, node)
+    fn fold_jsx_element_child(
+        &mut self,
+        node: JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementChild {
+        <V as FoldAstPath>::fold_jsx_element_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
-        <V as VisitAll>::visit_jsx_element_childs(&mut **self, node)
+    fn fold_jsx_element_childs(
+        &mut self,
+        node: Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXElementChild> {
+        <V as FoldAstPath>::fold_jsx_element_childs(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
-        <V as VisitAll>::visit_jsx_element_name(&mut **self, node)
+    fn fold_jsx_element_name(
+        &mut self,
+        node: JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementName {
+        <V as FoldAstPath>::fold_jsx_element_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
-        <V as VisitAll>::visit_jsx_empty_expr(&mut **self, node)
+    fn fold_jsx_empty_expr(
+        &mut self,
+        node: JSXEmptyExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXEmptyExpr {
+        <V as FoldAstPath>::fold_jsx_empty_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_expr(&mut self, node: &JSXExpr) {
-        <V as VisitAll>::visit_jsx_expr(&mut **self, node)
+    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
+        <V as FoldAstPath>::fold_jsx_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
-        <V as VisitAll>::visit_jsx_expr_container(&mut **self, node)
+    fn fold_jsx_expr_container(
+        &mut self,
+        node: JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXExprContainer {
+        <V as FoldAstPath>::fold_jsx_expr_container(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
-        <V as VisitAll>::visit_jsx_fragment(&mut **self, node)
+    fn fold_jsx_fragment(
+        &mut self,
+        node: JSXFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXFragment {
+        <V as FoldAstPath>::fold_jsx_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
-        <V as VisitAll>::visit_jsx_member_expr(&mut **self, node)
+    fn fold_jsx_member_expr(
+        &mut self,
+        node: JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXMemberExpr {
+        <V as FoldAstPath>::fold_jsx_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
-        <V as VisitAll>::visit_jsx_namespaced_name(&mut **self, node)
+    fn fold_jsx_namespaced_name(
+        &mut self,
+        node: JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXNamespacedName {
+        <V as FoldAstPath>::fold_jsx_namespaced_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_object(&mut self, node: &JSXObject) {
-        <V as VisitAll>::visit_jsx_object(&mut **self, node)
+    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
+        <V as FoldAstPath>::fold_jsx_object(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
-        <V as VisitAll>::visit_jsx_opening_element(&mut **self, node)
+    fn fold_jsx_opening_element(
+        &mut self,
+        node: JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningElement {
+        <V as FoldAstPath>::fold_jsx_opening_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
-        <V as VisitAll>::visit_jsx_opening_fragment(&mut **self, node)
+    fn fold_jsx_opening_fragment(
+        &mut self,
+        node: JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningFragment {
+        <V as FoldAstPath>::fold_jsx_opening_fragment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
-        <V as VisitAll>::visit_jsx_spread_child(&mut **self, node)
+    fn fold_jsx_spread_child(
+        &mut self,
+        node: JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXSpreadChild {
+        <V as FoldAstPath>::fold_jsx_spread_child(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_jsx_text(&mut self, node: &JSXText) {
-        <V as VisitAll>::visit_jsx_text(&mut **self, node)
+    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
+        <V as FoldAstPath>::fold_jsx_text(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_key(&mut self, node: &Key) {
-        <V as VisitAll>::visit_key(&mut **self, node)
+    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
+        <V as FoldAstPath>::fold_key(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
-        <V as VisitAll>::visit_key_value_pat_prop(&mut **self, node)
+    fn fold_key_value_pat_prop(
+        &mut self,
+        node: KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValuePatProp {
+        <V as FoldAstPath>::fold_key_value_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
-        <V as VisitAll>::visit_key_value_prop(&mut **self, node)
+    fn fold_key_value_prop(
+        &mut self,
+        node: KeyValueProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValueProp {
+        <V as FoldAstPath>::fold_key_value_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
-        <V as VisitAll>::visit_labeled_stmt(&mut **self, node)
+    fn fold_labeled_stmt(
+        &mut self,
+        node: LabeledStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> LabeledStmt {
+        <V as FoldAstPath>::fold_labeled_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_lit(&mut self, node: &Lit) {
-        <V as VisitAll>::visit_lit(&mut **self, node)
+    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
+        <V as FoldAstPath>::fold_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_member_expr(&mut self, node: &MemberExpr) {
-        <V as VisitAll>::visit_member_expr(&mut **self, node)
+    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
+        <V as FoldAstPath>::fold_member_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_member_prop(&mut self, node: &MemberProp) {
-        <V as VisitAll>::visit_member_prop(&mut **self, node)
+    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
+        <V as FoldAstPath>::fold_member_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
-        <V as VisitAll>::visit_meta_prop_expr(&mut **self, node)
+    fn fold_meta_prop_expr(
+        &mut self,
+        node: MetaPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropExpr {
+        <V as FoldAstPath>::fold_meta_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
-        <V as VisitAll>::visit_meta_prop_kind(&mut **self, node)
+    fn fold_meta_prop_kind(
+        &mut self,
+        node: MetaPropKind,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropKind {
+        <V as FoldAstPath>::fold_meta_prop_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_method_kind(&mut self, node: &MethodKind) {
-        <V as VisitAll>::visit_method_kind(&mut **self, node)
+    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
+        <V as FoldAstPath>::fold_method_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_method_prop(&mut self, node: &MethodProp) {
-        <V as VisitAll>::visit_method_prop(&mut **self, node)
+    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
+        <V as FoldAstPath>::fold_method_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module(&mut self, node: &Module) {
-        <V as VisitAll>::visit_module(&mut **self, node)
+    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
+        <V as FoldAstPath>::fold_module(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_decl(&mut self, node: &ModuleDecl) {
-        <V as VisitAll>::visit_module_decl(&mut **self, node)
+    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
+        <V as FoldAstPath>::fold_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_export_name(&mut self, node: &ModuleExportName) {
-        <V as VisitAll>::visit_module_export_name(&mut **self, node)
+    fn fold_module_export_name(
+        &mut self,
+        node: ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) -> ModuleExportName {
+        <V as FoldAstPath>::fold_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_item(&mut self, node: &ModuleItem) {
-        <V as VisitAll>::visit_module_item(&mut **self, node)
+    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
+        <V as FoldAstPath>::fold_module_item(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_module_items(&mut self, node: &[ModuleItem]) {
-        <V as VisitAll>::visit_module_items(&mut **self, node)
+    fn fold_module_items(
+        &mut self,
+        node: Vec<ModuleItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ModuleItem> {
+        <V as FoldAstPath>::fold_module_items(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_named_export(&mut self, node: &NamedExport) {
-        <V as VisitAll>::visit_named_export(&mut **self, node)
+    fn fold_named_export(
+        &mut self,
+        node: NamedExport,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedExport {
+        <V as FoldAstPath>::fold_named_export(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_new_expr(&mut self, node: &NewExpr) {
-        <V as VisitAll>::visit_new_expr(&mut **self, node)
+    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
+        <V as FoldAstPath>::fold_new_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_null(&mut self, node: &Null) {
-        <V as VisitAll>::visit_null(&mut **self, node)
+    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
+        <V as FoldAstPath>::fold_null(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
-        <V as VisitAll>::visit_number(&mut **self, node)
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
+        <V as FoldAstPath>::fold_number(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_lit(&mut self, node: &ObjectLit) {
-        <V as VisitAll>::visit_object_lit(&mut **self, node)
+    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
+        <V as FoldAstPath>::fold_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_pat(&mut self, node: &ObjectPat) {
-        <V as VisitAll>::visit_object_pat(&mut **self, node)
+    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
+        <V as FoldAstPath>::fold_object_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
-        <V as VisitAll>::visit_object_pat_prop(&mut **self, node)
+    fn fold_object_pat_prop(
+        &mut self,
+        node: ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ObjectPatProp {
+        <V as FoldAstPath>::fold_object_pat_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
-        <V as VisitAll>::visit_object_pat_props(&mut **self, node)
+    fn fold_object_pat_props(
+        &mut self,
+        node: Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ObjectPatProp> {
+        <V as FoldAstPath>::fold_object_pat_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
-        <V as VisitAll>::visit_opt_accessibility(&mut **self, node)
+    fn fold_opt_accessibility(
+        &mut self,
+        node: Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Accessibility> {
+        <V as FoldAstPath>::fold_opt_accessibility(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
+        <V as FoldAstPath>::fold_opt_atom(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>) {
-        <V as VisitAll>::visit_opt_block_stmt(&mut **self, node)
+    fn fold_opt_block_stmt(
+        &mut self,
+        node: Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<BlockStmt> {
+        <V as FoldAstPath>::fold_opt_block_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_call(&mut self, node: &OptCall) {
-        <V as VisitAll>::visit_opt_call(&mut **self, node)
+    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
+        <V as FoldAstPath>::fold_opt_call(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>) {
-        <V as VisitAll>::visit_opt_catch_clause(&mut **self, node)
+    fn fold_opt_catch_clause(
+        &mut self,
+        node: Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<CatchClause> {
+        <V as FoldAstPath>::fold_opt_catch_clause(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
-        <V as VisitAll>::visit_opt_chain_base(&mut **self, node)
+    fn fold_opt_chain_base(
+        &mut self,
+        node: OptChainBase,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainBase {
+        <V as FoldAstPath>::fold_opt_chain_base(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
-        <V as VisitAll>::visit_opt_chain_expr(&mut **self, node)
+    fn fold_opt_chain_expr(
+        &mut self,
+        node: OptChainExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainExpr {
+        <V as FoldAstPath>::fold_opt_chain_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>) {
-        <V as VisitAll>::visit_opt_expr(&mut **self, node)
+    fn fold_opt_expr(
+        &mut self,
+        node: Option<Box<Expr>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Expr>> {
+        <V as FoldAstPath>::fold_opt_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>) {
-        <V as VisitAll>::visit_opt_expr_or_spread(&mut **self, node)
+    fn fold_opt_expr_or_spread(
+        &mut self,
+        node: Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ExprOrSpread> {
+        <V as FoldAstPath>::fold_opt_expr_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>) {
-        <V as VisitAll>::visit_opt_expr_or_spreads(&mut **self, node)
+    fn fold_opt_expr_or_spreads(
+        &mut self,
+        node: Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<ExprOrSpread>> {
+        <V as FoldAstPath>::fold_opt_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
-        <V as VisitAll>::visit_opt_ident(&mut **self, node)
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
+        <V as FoldAstPath>::fold_opt_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>) {
-        <V as VisitAll>::visit_opt_jsx_attr_value(&mut **self, node)
+    fn fold_opt_jsx_attr_value(
+        &mut self,
+        node: Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXAttrValue> {
+        <V as FoldAstPath>::fold_opt_jsx_attr_value(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>) {
-        <V as VisitAll>::visit_opt_jsx_closing_element(&mut **self, node)
+    fn fold_opt_jsx_closing_element(
+        &mut self,
+        node: Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXClosingElement> {
+        <V as FoldAstPath>::fold_opt_jsx_closing_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_module_export_name(&mut self, node: &Option<ModuleExportName>) {
-        <V as VisitAll>::visit_opt_module_export_name(&mut **self, node)
+    fn fold_opt_module_export_name(
+        &mut self,
+        node: Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ModuleExportName> {
+        <V as FoldAstPath>::fold_opt_module_export_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_object_lit(&mut self, node: &Option<Box<ObjectLit>>) {
-        <V as VisitAll>::visit_opt_object_lit(&mut **self, node)
+    fn fold_opt_object_lit(
+        &mut self,
+        node: Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ObjectLit>> {
+        <V as FoldAstPath>::fold_opt_object_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_pat(&mut self, node: &Option<Pat>) {
-        <V as VisitAll>::visit_opt_pat(&mut **self, node)
+    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
+        <V as FoldAstPath>::fold_opt_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_span(&mut self, node: &Option<swc_common::Span>) {
-        <V as VisitAll>::visit_opt_span(&mut **self, node)
+    fn fold_opt_span(
+        &mut self,
+        node: Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_common::Span> {
+        <V as FoldAstPath>::fold_opt_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>) {
-        <V as VisitAll>::visit_opt_stmt(&mut **self, node)
+    fn fold_opt_stmt(
+        &mut self,
+        node: Option<Box<Stmt>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Stmt>> {
+        <V as FoldAstPath>::fold_opt_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_str(&mut self, node: &Option<Box<Str>>) {
-        <V as VisitAll>::visit_opt_str(&mut **self, node)
+    fn fold_opt_str(
+        &mut self,
+        node: Option<Box<Str>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Str>> {
+        <V as FoldAstPath>::fold_opt_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>) {
-        <V as VisitAll>::visit_opt_true_plus_minus(&mut **self, node)
+    fn fold_opt_true_plus_minus(
+        &mut self,
+        node: Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TruePlusMinus> {
+        <V as FoldAstPath>::fold_opt_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>) {
-        <V as VisitAll>::visit_opt_ts_entity_name(&mut **self, node)
+    fn fold_opt_ts_entity_name(
+        &mut self,
+        node: Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsEntityName> {
+        <V as FoldAstPath>::fold_opt_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>) {
-        <V as VisitAll>::visit_opt_ts_namespace_body(&mut **self, node)
+    fn fold_opt_ts_namespace_body(
+        &mut self,
+        node: Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsNamespaceBody> {
+        <V as FoldAstPath>::fold_opt_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>) {
-        <V as VisitAll>::visit_opt_ts_type(&mut **self, node)
+    fn fold_opt_ts_type(
+        &mut self,
+        node: Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsType>> {
+        <V as FoldAstPath>::fold_opt_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>) {
-        <V as VisitAll>::visit_opt_ts_type_ann(&mut **self, node)
+    fn fold_opt_ts_type_ann(
+        &mut self,
+        node: Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeAnn>> {
+        <V as FoldAstPath>::fold_opt_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_decl(&mut self, node: &Option<Box<TsTypeParamDecl>>) {
-        <V as VisitAll>::visit_opt_ts_type_param_decl(&mut **self, node)
+    fn fold_opt_ts_type_param_decl(
+        &mut self,
+        node: Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamDecl>> {
+        <V as FoldAstPath>::fold_opt_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_instantiation(
+    fn fold_opt_ts_type_param_instantiation(
         &mut self,
-        node: &Option<Box<TsTypeParamInstantiation>>,
-    ) {
-        <V as VisitAll>::visit_opt_ts_type_param_instantiation(&mut **self, node)
+        node: Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamInstantiation>> {
+        <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>) {
-        <V as VisitAll>::visit_opt_var_decl_or_expr(&mut **self, node)
+    fn fold_opt_var_decl_or_expr(
+        &mut self,
+        node: Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<VarDeclOrExpr> {
+        <V as FoldAstPath>::fold_opt_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>]) {
-        <V as VisitAll>::visit_opt_vec_expr_or_spreads(&mut **self, node)
+    fn fold_opt_vec_expr_or_spreads(
+        &mut self,
+        node: Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<ExprOrSpread>> {
+        <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>]) {
-        <V as VisitAll>::visit_opt_vec_pats(&mut **self, node)
+    fn fold_opt_vec_pats(
+        &mut self,
+        node: Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<Pat>> {
+        <V as FoldAstPath>::fold_opt_vec_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_param(&mut self, node: &Param) {
-        <V as VisitAll>::visit_param(&mut **self, node)
+    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
+        <V as FoldAstPath>::fold_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp) {
-        <V as VisitAll>::visit_param_or_ts_param_prop(&mut **self, node)
+    fn fold_param_or_ts_param_prop(
+        &mut self,
+        node: ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ParamOrTsParamProp {
+        <V as FoldAstPath>::fold_param_or_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp]) {
-        <V as VisitAll>::visit_param_or_ts_param_props(&mut **self, node)
+    fn fold_param_or_ts_param_props(
+        &mut self,
+        node: Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ParamOrTsParamProp> {
+        <V as FoldAstPath>::fold_param_or_ts_param_props(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_params(&mut self, node: &[Param]) {
-        <V as VisitAll>::visit_params(&mut **self, node)
+    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
+        <V as FoldAstPath>::fold_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_paren_expr(&mut self, node: &ParenExpr) {
-        <V as VisitAll>::visit_paren_expr(&mut **self, node)
+    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
+        <V as FoldAstPath>::fold_paren_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pat(&mut self, node: &Pat) {
-        <V as VisitAll>::visit_pat(&mut **self, node)
+    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
+        <V as FoldAstPath>::fold_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_pats(&mut self, node: &[Pat]) {
-        <V as VisitAll>::visit_pats(&mut **self, node)
+    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
+        <V as FoldAstPath>::fold_pats(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_private_method(&mut self, node: &PrivateMethod) {
-        <V as VisitAll>::visit_private_method(&mut **self, node)
+    fn fold_private_method(
+        &mut self,
+        node: PrivateMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateMethod {
+        <V as FoldAstPath>::fold_private_method(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_private_name(&mut self, node: &PrivateName) {
-        <V as VisitAll>::visit_private_name(&mut **self, node)
+    fn fold_private_name(
+        &mut self,
+        node: PrivateName,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateName {
+        <V as FoldAstPath>::fold_private_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_private_prop(&mut self, node: &PrivateProp) {
-        <V as VisitAll>::visit_private_prop(&mut **self, node)
+    fn fold_private_prop(
+        &mut self,
+        node: PrivateProp,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateProp {
+        <V as FoldAstPath>::fold_private_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_program(&mut self, node: &Program) {
-        <V as VisitAll>::visit_program(&mut **self, node)
+    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
+        <V as FoldAstPath>::fold_program(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop(&mut self, node: &Prop) {
-        <V as VisitAll>::visit_prop(&mut **self, node)
+    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
+        <V as FoldAstPath>::fold_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop_name(&mut self, node: &PropName) {
-        <V as VisitAll>::visit_prop_name(&mut **self, node)
+    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
+        <V as FoldAstPath>::fold_prop_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
-        <V as VisitAll>::visit_prop_or_spread(&mut **self, node)
+    fn fold_prop_or_spread(
+        &mut self,
+        node: PropOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> PropOrSpread {
+        <V as FoldAstPath>::fold_prop_or_spread(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
-        <V as VisitAll>::visit_prop_or_spreads(&mut **self, node)
+    fn fold_prop_or_spreads(
+        &mut self,
+        node: Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PropOrSpread> {
+        <V as FoldAstPath>::fold_prop_or_spreads(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_regex(&mut self, node: &Regex) {
-        <V as VisitAll>::visit_regex(&mut **self, node)
+    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
+        <V as FoldAstPath>::fold_regex(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_rest_pat(&mut self, node: &RestPat) {
-        <V as VisitAll>::visit_rest_pat(&mut **self, node)
+    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
+        <V as FoldAstPath>::fold_rest_pat(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_return_stmt(&mut self, node: &ReturnStmt) {
-        <V as VisitAll>::visit_return_stmt(&mut **self, node)
+    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
+        <V as FoldAstPath>::fold_return_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_script(&mut self, node: &Script) {
-        <V as VisitAll>::visit_script(&mut **self, node)
+    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
+        <V as FoldAstPath>::fold_script(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_seq_expr(&mut self, node: &SeqExpr) {
-        <V as VisitAll>::visit_seq_expr(&mut **self, node)
+    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
+        <V as FoldAstPath>::fold_seq_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_setter_prop(&mut self, node: &SetterProp) {
-        <V as VisitAll>::visit_setter_prop(&mut **self, node)
+    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
+        <V as FoldAstPath>::fold_setter_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
-        <V as VisitAll>::visit_simple_assign_target(&mut **self, node)
+    fn fold_simple_assign_target(
+        &mut self,
+        node: SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleAssignTarget {
+        <V as FoldAstPath>::fold_simple_assign_target(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
+        <V as FoldAstPath>::fold_span(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_spread_element(&mut self, node: &SpreadElement) {
-        <V as VisitAll>::visit_spread_element(&mut **self, node)
+    fn fold_spread_element(
+        &mut self,
+        node: SpreadElement,
+        __ast_path: &mut AstKindPath,
+    ) -> SpreadElement {
+        <V as FoldAstPath>::fold_spread_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_static_block(&mut self, node: &StaticBlock) {
-        <V as VisitAll>::visit_static_block(&mut **self, node)
+    fn fold_static_block(
+        &mut self,
+        node: StaticBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> StaticBlock {
+        <V as FoldAstPath>::fold_static_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_stmt(&mut self, node: &Stmt) {
-        <V as VisitAll>::visit_stmt(&mut **self, node)
+    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
+        <V as FoldAstPath>::fold_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_stmts(&mut self, node: &[Stmt]) {
-        <V as VisitAll>::visit_stmts(&mut **self, node)
+    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
+        <V as FoldAstPath>::fold_stmts(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
-        <V as VisitAll>::visit_str(&mut **self, node)
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
+        <V as FoldAstPath>::fold_str(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_super(&mut self, node: &Super) {
-        <V as VisitAll>::visit_super(&mut **self, node)
+    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
+        <V as FoldAstPath>::fold_super(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_super_prop(&mut self, node: &SuperProp) {
-        <V as VisitAll>::visit_super_prop(&mut **self, node)
+    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
+        <V as FoldAstPath>::fold_super_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
-        <V as VisitAll>::visit_super_prop_expr(&mut **self, node)
+    fn fold_super_prop_expr(
+        &mut self,
+        node: SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> SuperPropExpr {
+        <V as FoldAstPath>::fold_super_prop_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_switch_case(&mut self, node: &SwitchCase) {
-        <V as VisitAll>::visit_switch_case(&mut **self, node)
+    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
+        <V as FoldAstPath>::fold_switch_case(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
-        <V as VisitAll>::visit_switch_cases(&mut **self, node)
+    fn fold_switch_cases(
+        &mut self,
+        node: Vec<SwitchCase>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SwitchCase> {
+        <V as FoldAstPath>::fold_switch_cases(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
-        <V as VisitAll>::visit_switch_stmt(&mut **self, node)
+    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
+        <V as FoldAstPath>::fold_switch_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_syntax_context(&mut self, node: &swc_common::SyntaxContext) {
-        <V as VisitAll>::visit_syntax_context(&mut **self, node)
+    fn fold_syntax_context(
+        &mut self,
+        node: swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::SyntaxContext {
+        <V as FoldAstPath>::fold_syntax_context(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
-        <V as VisitAll>::visit_tagged_tpl(&mut **self, node)
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
+        <V as FoldAstPath>::fold_tagged_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_this_expr(&mut self, node: &ThisExpr) {
-        <V as VisitAll>::visit_this_expr(&mut **self, node)
+    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
+        <V as FoldAstPath>::fold_this_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
-        <V as VisitAll>::visit_throw_stmt(&mut **self, node)
+    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
+        <V as FoldAstPath>::fold_throw_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tpl(&mut self, node: &Tpl) {
-        <V as VisitAll>::visit_tpl(&mut **self, node)
+    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
+        <V as FoldAstPath>::fold_tpl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tpl_element(&mut self, node: &TplElement) {
-        <V as VisitAll>::visit_tpl_element(&mut **self, node)
+    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
+        <V as FoldAstPath>::fold_tpl_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_tpl_elements(&mut self, node: &[TplElement]) {
-        <V as VisitAll>::visit_tpl_elements(&mut **self, node)
+    fn fold_tpl_elements(
+        &mut self,
+        node: Vec<TplElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TplElement> {
+        <V as FoldAstPath>::fold_tpl_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
-        <V as VisitAll>::visit_true_plus_minus(&mut **self, node)
+    fn fold_true_plus_minus(
+        &mut self,
+        node: TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) -> TruePlusMinus {
+        <V as FoldAstPath>::fold_true_plus_minus(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_try_stmt(&mut self, node: &TryStmt) {
-        <V as VisitAll>::visit_try_stmt(&mut **self, node)
+    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
+        <V as FoldAstPath>::fold_try_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_array_type(&mut self, node: &TsArrayType) {
-        <V as VisitAll>::visit_ts_array_type(&mut **self, node)
+    fn fold_ts_array_type(
+        &mut self,
+        node: TsArrayType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsArrayType {
+        <V as FoldAstPath>::fold_ts_array_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
-        <V as VisitAll>::visit_ts_as_expr(&mut **self, node)
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
+        <V as FoldAstPath>::fold_ts_as_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
-        <V as VisitAll>::visit_ts_call_signature_decl(&mut **self, node)
+    fn fold_ts_call_signature_decl(
+        &mut self,
+        node: TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsCallSignatureDecl {
+        <V as FoldAstPath>::fold_ts_call_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
-        <V as VisitAll>::visit_ts_conditional_type(&mut **self, node)
+    fn fold_ts_conditional_type(
+        &mut self,
+        node: TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConditionalType {
+        <V as FoldAstPath>::fold_ts_conditional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
-        <V as VisitAll>::visit_ts_const_assertion(&mut **self, node)
+    fn fold_ts_const_assertion(
+        &mut self,
+        node: TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstAssertion {
+        <V as FoldAstPath>::fold_ts_const_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
-        <V as VisitAll>::visit_ts_construct_signature_decl(&mut **self, node)
+    fn fold_ts_construct_signature_decl(
+        &mut self,
+        node: TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructSignatureDecl {
+        <V as FoldAstPath>::fold_ts_construct_signature_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
-        <V as VisitAll>::visit_ts_constructor_type(&mut **self, node)
+    fn fold_ts_constructor_type(
+        &mut self,
+        node: TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructorType {
+        <V as FoldAstPath>::fold_ts_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
-        <V as VisitAll>::visit_ts_entity_name(&mut **self, node)
+    fn fold_ts_entity_name(
+        &mut self,
+        node: TsEntityName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEntityName {
+        <V as FoldAstPath>::fold_ts_entity_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
-        <V as VisitAll>::visit_ts_enum_decl(&mut **self, node)
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
+        <V as FoldAstPath>::fold_ts_enum_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
-        <V as VisitAll>::visit_ts_enum_member(&mut **self, node)
+    fn fold_ts_enum_member(
+        &mut self,
+        node: TsEnumMember,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMember {
+        <V as FoldAstPath>::fold_ts_enum_member(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
-        <V as VisitAll>::visit_ts_enum_member_id(&mut **self, node)
+    fn fold_ts_enum_member_id(
+        &mut self,
+        node: TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMemberId {
+        <V as FoldAstPath>::fold_ts_enum_member_id(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
-        <V as VisitAll>::visit_ts_enum_members(&mut **self, node)
+    fn fold_ts_enum_members(
+        &mut self,
+        node: Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsEnumMember> {
+        <V as FoldAstPath>::fold_ts_enum_members(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
-        <V as VisitAll>::visit_ts_export_assignment(&mut **self, node)
+    fn fold_ts_export_assignment(
+        &mut self,
+        node: TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExportAssignment {
+        <V as FoldAstPath>::fold_ts_export_assignment(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs) {
-        <V as VisitAll>::visit_ts_expr_with_type_args(&mut **self, node)
+    fn fold_ts_expr_with_type_args(
+        &mut self,
+        node: TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExprWithTypeArgs {
+        <V as FoldAstPath>::fold_ts_expr_with_type_args(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs]) {
-        <V as VisitAll>::visit_ts_expr_with_type_argss(&mut **self, node)
+    fn fold_ts_expr_with_type_argss(
+        &mut self,
+        node: Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsExprWithTypeArgs> {
+        <V as FoldAstPath>::fold_ts_expr_with_type_argss(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
-        <V as VisitAll>::visit_ts_external_module_ref(&mut **self, node)
+    fn fold_ts_external_module_ref(
+        &mut self,
+        node: TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExternalModuleRef {
+        <V as FoldAstPath>::fold_ts_external_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType) {
-        <V as VisitAll>::visit_ts_fn_or_constructor_type(&mut **self, node)
+    fn fold_ts_fn_or_constructor_type(
+        &mut self,
+        node: TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsFnOrConstructorType {
+        <V as FoldAstPath>::fold_ts_fn_or_constructor_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
-        <V as VisitAll>::visit_ts_fn_param(&mut **self, node)
+    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
+        <V as FoldAstPath>::fold_ts_fn_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
-        <V as VisitAll>::visit_ts_fn_params(&mut **self, node)
+    fn fold_ts_fn_params(
+        &mut self,
+        node: Vec<TsFnParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsFnParam> {
+        <V as FoldAstPath>::fold_ts_fn_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_fn_type(&mut self, node: &TsFnType) {
-        <V as VisitAll>::visit_ts_fn_type(&mut **self, node)
+    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
+        <V as FoldAstPath>::fold_ts_fn_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
-        <V as VisitAll>::visit_ts_getter_signature(&mut **self, node)
+    fn fold_ts_getter_signature(
+        &mut self,
+        node: TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsGetterSignature {
+        <V as FoldAstPath>::fold_ts_getter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
-        <V as VisitAll>::visit_ts_import_equals_decl(&mut **self, node)
+    fn fold_ts_import_equals_decl(
+        &mut self,
+        node: TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportEqualsDecl {
+        <V as FoldAstPath>::fold_ts_import_equals_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_import_type(&mut self, node: &TsImportType) {
-        <V as VisitAll>::visit_ts_import_type(&mut **self, node)
+    fn fold_ts_import_type(
+        &mut self,
+        node: TsImportType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportType {
+        <V as FoldAstPath>::fold_ts_import_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
-        <V as VisitAll>::visit_ts_index_signature(&mut **self, node)
+    fn fold_ts_index_signature(
+        &mut self,
+        node: TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexSignature {
+        <V as FoldAstPath>::fold_ts_index_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
-        <V as VisitAll>::visit_ts_indexed_access_type(&mut **self, node)
+    fn fold_ts_indexed_access_type(
+        &mut self,
+        node: TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexedAccessType {
+        <V as FoldAstPath>::fold_ts_indexed_access_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_infer_type(&mut self, node: &TsInferType) {
-        <V as VisitAll>::visit_ts_infer_type(&mut **self, node)
+    fn fold_ts_infer_type(
+        &mut self,
+        node: TsInferType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInferType {
+        <V as FoldAstPath>::fold_ts_infer_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
-        <V as VisitAll>::visit_ts_instantiation(&mut **self, node)
+    fn fold_ts_instantiation(
+        &mut self,
+        node: TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInstantiation {
+        <V as FoldAstPath>::fold_ts_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
-        <V as VisitAll>::visit_ts_interface_body(&mut **self, node)
+    fn fold_ts_interface_body(
+        &mut self,
+        node: TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceBody {
+        <V as FoldAstPath>::fold_ts_interface_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
-        <V as VisitAll>::visit_ts_interface_decl(&mut **self, node)
+    fn fold_ts_interface_decl(
+        &mut self,
+        node: TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceDecl {
+        <V as FoldAstPath>::fold_ts_interface_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
-        <V as VisitAll>::visit_ts_intersection_type(&mut **self, node)
+    fn fold_ts_intersection_type(
+        &mut self,
+        node: TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIntersectionType {
+        <V as FoldAstPath>::fold_ts_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
-        <V as VisitAll>::visit_ts_keyword_type(&mut **self, node)
+    fn fold_ts_keyword_type(
+        &mut self,
+        node: TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordType {
+        <V as FoldAstPath>::fold_ts_keyword_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
-        <V as VisitAll>::visit_ts_keyword_type_kind(&mut **self, node)
+    fn fold_ts_keyword_type_kind(
+        &mut self,
+        node: TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordTypeKind {
+        <V as FoldAstPath>::fold_ts_keyword_type_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_lit(&mut self, node: &TsLit) {
-        <V as VisitAll>::visit_ts_lit(&mut **self, node)
+    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
+        <V as FoldAstPath>::fold_ts_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_lit_type(&mut self, node: &TsLitType) {
-        <V as VisitAll>::visit_ts_lit_type(&mut **self, node)
+    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
+        <V as FoldAstPath>::fold_ts_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
-        <V as VisitAll>::visit_ts_mapped_type(&mut **self, node)
+    fn fold_ts_mapped_type(
+        &mut self,
+        node: TsMappedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMappedType {
+        <V as FoldAstPath>::fold_ts_mapped_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
-        <V as VisitAll>::visit_ts_method_signature(&mut **self, node)
+    fn fold_ts_method_signature(
+        &mut self,
+        node: TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMethodSignature {
+        <V as FoldAstPath>::fold_ts_method_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
-        <V as VisitAll>::visit_ts_module_block(&mut **self, node)
+    fn fold_ts_module_block(
+        &mut self,
+        node: TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleBlock {
+        <V as FoldAstPath>::fold_ts_module_block(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
-        <V as VisitAll>::visit_ts_module_decl(&mut **self, node)
+    fn fold_ts_module_decl(
+        &mut self,
+        node: TsModuleDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleDecl {
+        <V as FoldAstPath>::fold_ts_module_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_name(&mut self, node: &TsModuleName) {
-        <V as VisitAll>::visit_ts_module_name(&mut **self, node)
+    fn fold_ts_module_name(
+        &mut self,
+        node: TsModuleName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleName {
+        <V as FoldAstPath>::fold_ts_module_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
-        <V as VisitAll>::visit_ts_module_ref(&mut **self, node)
+    fn fold_ts_module_ref(
+        &mut self,
+        node: TsModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleRef {
+        <V as FoldAstPath>::fold_ts_module_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
-        <V as VisitAll>::visit_ts_namespace_body(&mut **self, node)
+    fn fold_ts_namespace_body(
+        &mut self,
+        node: TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceBody {
+        <V as FoldAstPath>::fold_ts_namespace_body(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
-        <V as VisitAll>::visit_ts_namespace_decl(&mut **self, node)
+    fn fold_ts_namespace_decl(
+        &mut self,
+        node: TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceDecl {
+        <V as FoldAstPath>::fold_ts_namespace_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
-        <V as VisitAll>::visit_ts_namespace_export_decl(&mut **self, node)
+    fn fold_ts_namespace_export_decl(
+        &mut self,
+        node: TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceExportDecl {
+        <V as FoldAstPath>::fold_ts_namespace_export_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
-        <V as VisitAll>::visit_ts_non_null_expr(&mut **self, node)
+    fn fold_ts_non_null_expr(
+        &mut self,
+        node: TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNonNullExpr {
+        <V as FoldAstPath>::fold_ts_non_null_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
-        <V as VisitAll>::visit_ts_optional_type(&mut **self, node)
+    fn fold_ts_optional_type(
+        &mut self,
+        node: TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsOptionalType {
+        <V as FoldAstPath>::fold_ts_optional_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
-        <V as VisitAll>::visit_ts_param_prop(&mut **self, node)
+    fn fold_ts_param_prop(
+        &mut self,
+        node: TsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamProp {
+        <V as FoldAstPath>::fold_ts_param_prop(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
-        <V as VisitAll>::visit_ts_param_prop_param(&mut **self, node)
+    fn fold_ts_param_prop_param(
+        &mut self,
+        node: TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamPropParam {
+        <V as FoldAstPath>::fold_ts_param_prop_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
-        <V as VisitAll>::visit_ts_parenthesized_type(&mut **self, node)
+    fn fold_ts_parenthesized_type(
+        &mut self,
+        node: TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParenthesizedType {
+        <V as FoldAstPath>::fold_ts_parenthesized_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
-        <V as VisitAll>::visit_ts_property_signature(&mut **self, node)
+    fn fold_ts_property_signature(
+        &mut self,
+        node: TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsPropertySignature {
+        <V as FoldAstPath>::fold_ts_property_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
-        <V as VisitAll>::visit_ts_qualified_name(&mut **self, node)
+    fn fold_ts_qualified_name(
+        &mut self,
+        node: TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsQualifiedName {
+        <V as FoldAstPath>::fold_ts_qualified_name(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_rest_type(&mut self, node: &TsRestType) {
-        <V as VisitAll>::visit_ts_rest_type(&mut **self, node)
+    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
+        <V as FoldAstPath>::fold_ts_rest_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
-        <V as VisitAll>::visit_ts_satisfies_expr(&mut **self, node)
+    fn fold_ts_satisfies_expr(
+        &mut self,
+        node: TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSatisfiesExpr {
+        <V as FoldAstPath>::fold_ts_satisfies_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
-        <V as VisitAll>::visit_ts_setter_signature(&mut **self, node)
+    fn fold_ts_setter_signature(
+        &mut self,
+        node: TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSetterSignature {
+        <V as FoldAstPath>::fold_ts_setter_signature(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_this_type(&mut self, node: &TsThisType) {
-        <V as VisitAll>::visit_ts_this_type(&mut **self, node)
+    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
+        <V as FoldAstPath>::fold_ts_this_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent) {
-        <V as VisitAll>::visit_ts_this_type_or_ident(&mut **self, node)
+    fn fold_ts_this_type_or_ident(
+        &mut self,
+        node: TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> TsThisTypeOrIdent {
+        <V as FoldAstPath>::fold_ts_this_type_or_ident(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
-        <V as VisitAll>::visit_ts_tpl_lit_type(&mut **self, node)
+    fn fold_ts_tpl_lit_type(
+        &mut self,
+        node: TsTplLitType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTplLitType {
+        <V as FoldAstPath>::fold_ts_tpl_lit_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
-        <V as VisitAll>::visit_ts_tuple_element(&mut **self, node)
+    fn fold_ts_tuple_element(
+        &mut self,
+        node: TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleElement {
+        <V as FoldAstPath>::fold_ts_tuple_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
-        <V as VisitAll>::visit_ts_tuple_elements(&mut **self, node)
+    fn fold_ts_tuple_elements(
+        &mut self,
+        node: Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTupleElement> {
+        <V as FoldAstPath>::fold_ts_tuple_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
-        <V as VisitAll>::visit_ts_tuple_type(&mut **self, node)
+    fn fold_ts_tuple_type(
+        &mut self,
+        node: TsTupleType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleType {
+        <V as FoldAstPath>::fold_ts_tuple_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type(&mut self, node: &TsType) {
-        <V as VisitAll>::visit_ts_type(&mut **self, node)
+    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
+        <V as FoldAstPath>::fold_ts_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
-        <V as VisitAll>::visit_ts_type_alias_decl(&mut **self, node)
+    fn fold_ts_type_alias_decl(
+        &mut self,
+        node: TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAliasDecl {
+        <V as FoldAstPath>::fold_ts_type_alias_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
-        <V as VisitAll>::visit_ts_type_ann(&mut **self, node)
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
+        <V as FoldAstPath>::fold_ts_type_ann(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
-        <V as VisitAll>::visit_ts_type_assertion(&mut **self, node)
+    fn fold_ts_type_assertion(
+        &mut self,
+        node: TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAssertion {
+        <V as FoldAstPath>::fold_ts_type_assertion(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
-        <V as VisitAll>::visit_ts_type_element(&mut **self, node)
+    fn fold_ts_type_element(
+        &mut self,
+        node: TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeElement {
+        <V as FoldAstPath>::fold_ts_type_element(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
-        <V as VisitAll>::visit_ts_type_elements(&mut **self, node)
+    fn fold_ts_type_elements(
+        &mut self,
+        node: Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeElement> {
+        <V as FoldAstPath>::fold_ts_type_elements(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
-        <V as VisitAll>::visit_ts_type_lit(&mut **self, node)
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
+        <V as FoldAstPath>::fold_ts_type_lit(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
-        <V as VisitAll>::visit_ts_type_operator(&mut **self, node)
+    fn fold_ts_type_operator(
+        &mut self,
+        node: TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperator {
+        <V as FoldAstPath>::fold_ts_type_operator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
-        <V as VisitAll>::visit_ts_type_operator_op(&mut **self, node)
+    fn fold_ts_type_operator_op(
+        &mut self,
+        node: TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperatorOp {
+        <V as FoldAstPath>::fold_ts_type_operator_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
-        <V as VisitAll>::visit_ts_type_param(&mut **self, node)
+    fn fold_ts_type_param(
+        &mut self,
+        node: TsTypeParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParam {
+        <V as FoldAstPath>::fold_ts_type_param(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
-        <V as VisitAll>::visit_ts_type_param_decl(&mut **self, node)
+    fn fold_ts_type_param_decl(
+        &mut self,
+        node: TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamDecl {
+        <V as FoldAstPath>::fold_ts_type_param_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
-        <V as VisitAll>::visit_ts_type_param_instantiation(&mut **self, node)
+    fn fold_ts_type_param_instantiation(
+        &mut self,
+        node: TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamInstantiation {
+        <V as FoldAstPath>::fold_ts_type_param_instantiation(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
-        <V as VisitAll>::visit_ts_type_params(&mut **self, node)
+    fn fold_ts_type_params(
+        &mut self,
+        node: Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeParam> {
+        <V as FoldAstPath>::fold_ts_type_params(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
-        <V as VisitAll>::visit_ts_type_predicate(&mut **self, node)
+    fn fold_ts_type_predicate(
+        &mut self,
+        node: TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypePredicate {
+        <V as FoldAstPath>::fold_ts_type_predicate(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
-        <V as VisitAll>::visit_ts_type_query(&mut **self, node)
+    fn fold_ts_type_query(
+        &mut self,
+        node: TsTypeQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQuery {
+        <V as FoldAstPath>::fold_ts_type_query(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
-        <V as VisitAll>::visit_ts_type_query_expr(&mut **self, node)
+    fn fold_ts_type_query_expr(
+        &mut self,
+        node: TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQueryExpr {
+        <V as FoldAstPath>::fold_ts_type_query_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
-        <V as VisitAll>::visit_ts_type_ref(&mut **self, node)
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
+        <V as FoldAstPath>::fold_ts_type_ref(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
-        <V as VisitAll>::visit_ts_types(&mut **self, node)
+    fn fold_ts_types(
+        &mut self,
+        node: Vec<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Box<TsType>> {
+        <V as FoldAstPath>::fold_ts_types(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_union_or_intersection_type(&mut self, node: &TsUnionOrIntersectionType) {
-        <V as VisitAll>::visit_ts_union_or_intersection_type(&mut **self, node)
+    fn fold_ts_union_or_intersection_type(
+        &mut self,
+        node: TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionOrIntersectionType {
+        <V as FoldAstPath>::fold_ts_union_or_intersection_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_ts_union_type(&mut self, node: &TsUnionType) {
-        <V as VisitAll>::visit_ts_union_type(&mut **self, node)
+    fn fold_ts_union_type(
+        &mut self,
+        node: TsUnionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionType {
+        <V as FoldAstPath>::fold_ts_union_type(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_unary_expr(&mut self, node: &UnaryExpr) {
-        <V as VisitAll>::visit_unary_expr(&mut **self, node)
+    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
+        <V as FoldAstPath>::fold_unary_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_unary_op(&mut self, node: &UnaryOp) {
-        <V as VisitAll>::visit_unary_op(&mut **self, node)
+    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
+        <V as FoldAstPath>::fold_unary_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_update_expr(&mut self, node: &UpdateExpr) {
-        <V as VisitAll>::visit_update_expr(&mut **self, node)
+    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
+        <V as FoldAstPath>::fold_update_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_update_op(&mut self, node: &UpdateOp) {
-        <V as VisitAll>::visit_update_op(&mut **self, node)
+    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
+        <V as FoldAstPath>::fold_update_op(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_using_decl(&mut self, node: &UsingDecl) {
-        <V as VisitAll>::visit_using_decl(&mut **self, node)
+    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
+        <V as FoldAstPath>::fold_using_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_decl(&mut self, node: &VarDecl) {
-        <V as VisitAll>::visit_var_decl(&mut **self, node)
+    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
+        <V as FoldAstPath>::fold_var_decl(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
-        <V as VisitAll>::visit_var_decl_kind(&mut **self, node)
+    fn fold_var_decl_kind(
+        &mut self,
+        node: VarDeclKind,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclKind {
+        <V as FoldAstPath>::fold_var_decl_kind(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
-        <V as VisitAll>::visit_var_decl_or_expr(&mut **self, node)
+    fn fold_var_decl_or_expr(
+        &mut self,
+        node: VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclOrExpr {
+        <V as FoldAstPath>::fold_var_decl_or_expr(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_declarator(&mut self, node: &VarDeclarator) {
-        <V as VisitAll>::visit_var_declarator(&mut **self, node)
+    fn fold_var_declarator(
+        &mut self,
+        node: VarDeclarator,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclarator {
+        <V as FoldAstPath>::fold_var_declarator(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
-        <V as VisitAll>::visit_var_declarators(&mut **self, node)
+    fn fold_var_declarators(
+        &mut self,
+        node: Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<VarDeclarator> {
+        <V as FoldAstPath>::fold_var_declarators(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_while_stmt(&mut self, node: &WhileStmt) {
-        <V as VisitAll>::visit_while_stmt(&mut **self, node)
+    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
+        <V as FoldAstPath>::fold_while_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_with_stmt(&mut self, node: &WithStmt) {
-        <V as VisitAll>::visit_with_stmt(&mut **self, node)
+    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
+        <V as FoldAstPath>::fold_with_stmt(&mut **self, node, __ast_path)
     }
 
     #[inline]
-    fn visit_yield_expr(&mut self, node: &YieldExpr) {
-        <V as VisitAll>::visit_yield_expr(&mut **self, node)
+    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
+        <V as FoldAstPath>::fold_yield_expr(&mut **self, node, __ast_path)
     }
 }
-impl<A, B> VisitAll for ::swc_visit::Either<A, B>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<A, B> FoldAstPath for ::swc_visit::Either<A, B>
 where
-    A: VisitAll,
-    B: VisitAll,
+    A: FoldAstPath,
+    B: FoldAstPath,
 {
     #[inline]
-    fn visit_accessibility(&mut self, node: &Accessibility) {
+    fn fold_accessibility(
+        &mut self,
+        node: Accessibility,
+        __ast_path: &mut AstKindPath,
+    ) -> Accessibility {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_accessibility(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_accessibility(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_accessibility(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_accessibility(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_array_lit(&mut self, node: &ArrayLit) {
+    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_array_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_array_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_array_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_array_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_array_pat(&mut self, node: &ArrayPat) {
+    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_array_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_array_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_array_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_array_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
+    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_arrow_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_arrow_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_arrow_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_arrow_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_assign_expr(&mut self, node: &AssignExpr) {
+    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_assign_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_assign_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_assign_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_assign_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_assign_op(&mut self, node: &AssignOp) {
+    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_assign_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_assign_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_assign_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_assign_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_assign_pat(&mut self, node: &AssignPat) {
+    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_assign_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_assign_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_assign_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_assign_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
+    fn fold_assign_pat_prop(
+        &mut self,
+        node: AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignPatProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_assign_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_assign_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_assign_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_assign_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_assign_prop(&mut self, node: &AssignProp) {
+    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_assign_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_assign_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_assign_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_assign_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_assign_target(&mut self, node: &AssignTarget) {
+    fn fold_assign_target(
+        &mut self,
+        node: AssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTarget {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_assign_target(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_assign_target(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_assign_target(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_assign_target(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
+    fn fold_assign_target_pat(
+        &mut self,
+        node: AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTargetPat {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_assign_target_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_assign_target_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_assign_target_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_assign_target_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_atom(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
+    fn fold_auto_accessor(
+        &mut self,
+        node: AutoAccessor,
+        __ast_path: &mut AstKindPath,
+    ) -> AutoAccessor {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_auto_accessor(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_auto_accessor(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_auto_accessor(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_auto_accessor(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_await_expr(&mut self, node: &AwaitExpr) {
+    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_await_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_await_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_await_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_await_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_big_int(&mut self, node: &BigInt) {
+    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_big_int(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_big_int(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_big_int(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_big_int(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_big_int_value(&mut self, node: &BigIntValue) {
+    fn fold_big_int_value(
+        &mut self,
+        node: BigIntValue,
+        __ast_path: &mut AstKindPath,
+    ) -> BigIntValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_big_int_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_big_int_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_big_int_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_big_int_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_bin_expr(&mut self, node: &BinExpr) {
+    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_bin_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_bin_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_bin_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_bin_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_binary_op(&mut self, node: &BinaryOp) {
+    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_binary_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_binary_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_binary_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_binary_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_binding_ident(&mut self, node: &BindingIdent) {
+    fn fold_binding_ident(
+        &mut self,
+        node: BindingIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> BindingIdent {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_binding_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_binding_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_binding_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_binding_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_block_stmt(&mut self, node: &BlockStmt) {
+    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_block_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_block_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_block_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_block_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
+    fn fold_block_stmt_or_expr(
+        &mut self,
+        node: BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> BlockStmtOrExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_block_stmt_or_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_block_stmt_or_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_block_stmt_or_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_block_stmt_or_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_bool(&mut self, node: &Bool) {
+    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_bool(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_bool(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_bool(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_bool(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_break_stmt(&mut self, node: &BreakStmt) {
+    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_break_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_break_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_break_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_break_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_call_expr(&mut self, node: &CallExpr) {
+    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_call_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_call_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_call_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_call_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_callee(&mut self, node: &Callee) {
+    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_callee(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_callee(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_callee(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_callee(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_catch_clause(&mut self, node: &CatchClause) {
+    fn fold_catch_clause(
+        &mut self,
+        node: CatchClause,
+        __ast_path: &mut AstKindPath,
+    ) -> CatchClause {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_catch_clause(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_catch_clause(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_catch_clause(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_catch_clause(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_class(&mut self, node: &Class) {
+    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_class(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_class(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_class_decl(&mut self, node: &ClassDecl) {
+    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_class_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_class_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_class_expr(&mut self, node: &ClassExpr) {
+    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_class_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_class_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_class_member(&mut self, node: &ClassMember) {
+    fn fold_class_member(
+        &mut self,
+        node: ClassMember,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMember {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class_member(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class_member(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_class_member(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_class_member(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_class_members(&mut self, node: &[ClassMember]) {
+    fn fold_class_members(
+        &mut self,
+        node: Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ClassMember> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class_members(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class_members(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_class_members(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_class_members(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_class_method(&mut self, node: &ClassMethod) {
+    fn fold_class_method(
+        &mut self,
+        node: ClassMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMethod {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class_method(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class_method(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_class_method(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_class_method(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_class_prop(&mut self, node: &ClassProp) {
+    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_class_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_class_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_class_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_class_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
+    fn fold_computed_prop_name(
+        &mut self,
+        node: ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) -> ComputedPropName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_computed_prop_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_computed_prop_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_computed_prop_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_computed_prop_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_cond_expr(&mut self, node: &CondExpr) {
+    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_cond_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_cond_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_cond_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_cond_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_constructor(&mut self, node: &Constructor) {
+    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_constructor(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_constructor(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_constructor(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_constructor(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
+    fn fold_continue_stmt(
+        &mut self,
+        node: ContinueStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> ContinueStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_continue_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_continue_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_continue_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_continue_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
+    fn fold_debugger_stmt(
+        &mut self,
+        node: DebuggerStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DebuggerStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_debugger_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_debugger_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_debugger_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_debugger_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_decl(&mut self, node: &Decl) {
+    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_decl(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_decl(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_decorator(&mut self, node: &Decorator) {
+    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_decorator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_decorator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_decorator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_decorator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_decorators(&mut self, node: &[Decorator]) {
+    fn fold_decorators(
+        &mut self,
+        node: Vec<Decorator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Decorator> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_decorators(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_decorators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_decorators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_decorators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_default_decl(&mut self, node: &DefaultDecl) {
+    fn fold_default_decl(
+        &mut self,
+        node: DefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> DefaultDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_default_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_default_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_default_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_default_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
+    fn fold_do_while_stmt(
+        &mut self,
+        node: DoWhileStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DoWhileStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_do_while_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_do_while_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_do_while_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_do_while_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
+    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_empty_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_empty_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_empty_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_empty_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_es_version(&mut self, node: &EsVersion) {
+    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_es_version(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_es_version(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_es_version(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_es_version(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_export_all(&mut self, node: &ExportAll) {
+    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_export_all(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_export_all(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_export_all(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_export_all(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_export_decl(&mut self, node: &ExportDecl) {
+    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_export_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_export_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_export_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_export_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
+    fn fold_export_default_decl(
+        &mut self,
+        node: ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_export_default_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_export_default_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_export_default_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_export_default_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
+    fn fold_export_default_expr(
+        &mut self,
+        node: ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_export_default_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_export_default_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_export_default_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_export_default_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
+    fn fold_export_default_specifier(
+        &mut self,
+        node: ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultSpecifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_export_default_specifier(visitor, node)
+                FoldAstPath::fold_export_default_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_export_default_specifier(visitor, node)
+                FoldAstPath::fold_export_default_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
+    fn fold_export_named_specifier(
+        &mut self,
+        node: ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamedSpecifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_export_named_specifier(visitor, node)
+                FoldAstPath::fold_export_named_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_export_named_specifier(visitor, node)
+                FoldAstPath::fold_export_named_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
+    fn fold_export_namespace_specifier(
+        &mut self,
+        node: ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamespaceSpecifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_export_namespace_specifier(visitor, node)
+                FoldAstPath::fold_export_namespace_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_export_namespace_specifier(visitor, node)
+                FoldAstPath::fold_export_namespace_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
+    fn fold_export_specifier(
+        &mut self,
+        node: ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_export_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_export_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_export_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_export_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
+    fn fold_export_specifiers(
+        &mut self,
+        node: Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExportSpecifier> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_export_specifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_export_specifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_export_specifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_export_specifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_expr(&mut self, node: &Expr) {
+    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_expr(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_expr(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
+    fn fold_expr_or_spread(
+        &mut self,
+        node: ExprOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> ExprOrSpread {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_expr_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_expr_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_expr_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_expr_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
+    fn fold_expr_or_spreads(
+        &mut self,
+        node: Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExprOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_expr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_expr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_expr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_expr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_expr_stmt(&mut self, node: &ExprStmt) {
+    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_expr_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_expr_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_expr_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_expr_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_exprs(&mut self, node: &[Box<Expr>]) {
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_exprs(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_exprs(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_exprs(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_exprs(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_fn_decl(&mut self, node: &FnDecl) {
+    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_fn_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_fn_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_fn_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_fn_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_fn_expr(&mut self, node: &FnExpr) {
+    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_fn_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_fn_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_fn_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_fn_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_for_head(&mut self, node: &ForHead) {
+    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_for_head(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_for_head(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_for_head(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_for_head(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
+    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_for_in_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_for_in_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_for_in_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_for_in_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_for_of_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_for_of_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_for_of_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_for_of_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_for_stmt(&mut self, node: &ForStmt) {
+    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_for_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_for_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_for_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_for_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_function(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_function(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_function(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_function(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_getter_prop(&mut self, node: &GetterProp) {
+    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_getter_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_getter_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_getter_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_getter_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_ident(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_ident_name(&mut self, node: &IdentName) {
+    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ident_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ident_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ident_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ident_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_if_stmt(&mut self, node: &IfStmt) {
+    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_if_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_if_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_if_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_if_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import(&mut self, node: &Import) {
+    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_import(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_decl(&mut self, node: &ImportDecl) {
+    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
+    fn fold_import_default_specifier(
+        &mut self,
+        node: ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportDefaultSpecifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_import_default_specifier(visitor, node)
+                FoldAstPath::fold_import_default_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_import_default_specifier(visitor, node)
+                FoldAstPath::fold_import_default_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
+    fn fold_import_named_specifier(
+        &mut self,
+        node: ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportNamedSpecifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_import_named_specifier(visitor, node)
+                FoldAstPath::fold_import_named_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_import_named_specifier(visitor, node)
+                FoldAstPath::fold_import_named_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_import_phase(&mut self, node: &ImportPhase) {
+    fn fold_import_phase(
+        &mut self,
+        node: ImportPhase,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPhase {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_phase(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_phase(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_phase(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_phase(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
+    fn fold_import_specifier(
+        &mut self,
+        node: ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportSpecifier {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_specifier(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_specifier(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_specifier(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_specifier(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
+    fn fold_import_specifiers(
+        &mut self,
+        node: Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportSpecifier> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_specifiers(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_specifiers(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_specifiers(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_specifiers(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
+    fn fold_import_star_as_specifier(
+        &mut self,
+        node: ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportStarAsSpecifier {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_import_star_as_specifier(visitor, node)
+                FoldAstPath::fold_import_star_as_specifier(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_import_star_as_specifier(visitor, node)
+                FoldAstPath::fold_import_star_as_specifier(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_import_with(&mut self, node: &ImportWith) {
+    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_with(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_with(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_with(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_with(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_with_item(&mut self, node: &ImportWithItem) {
+    fn fold_import_with_item(
+        &mut self,
+        node: ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportWithItem {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_with_item(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_with_item(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_with_item(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_with_item(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
+    fn fold_import_with_items(
+        &mut self,
+        node: Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportWithItem> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_import_with_items(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_import_with_items(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_import_with_items(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_import_with_items(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_invalid(&mut self, node: &Invalid) {
+    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_invalid(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_invalid(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_invalid(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_invalid(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_attr(&mut self, node: &JSXAttr) {
+    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_attr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_attr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_attr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_attr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
+    fn fold_jsx_attr_name(
+        &mut self,
+        node: JSXAttrName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_attr_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_attr_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_attr_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_attr_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
+    fn fold_jsx_attr_or_spread(
+        &mut self,
+        node: JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrOrSpread {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_attr_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_attr_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_attr_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_attr_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
+    fn fold_jsx_attr_or_spreads(
+        &mut self,
+        node: Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXAttrOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_attr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_attr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_attr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_attr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
+    fn fold_jsx_attr_value(
+        &mut self,
+        node: JSXAttrValue,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrValue {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_attr_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_attr_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_attr_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_attr_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
+    fn fold_jsx_closing_element(
+        &mut self,
+        node: JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingElement {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_closing_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_closing_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_closing_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_closing_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
+    fn fold_jsx_closing_fragment(
+        &mut self,
+        node: JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingFragment {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_closing_fragment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_closing_fragment(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_jsx_closing_fragment(visitor, node)
+                FoldAstPath::fold_jsx_closing_fragment(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_jsx_element(&mut self, node: &JSXElement) {
+    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
+    fn fold_jsx_element_child(
+        &mut self,
+        node: JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementChild {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_element_child(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_element_child(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_element_child(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_element_child(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
+    fn fold_jsx_element_childs(
+        &mut self,
+        node: Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXElementChild> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_element_childs(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_element_childs(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_element_childs(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_element_childs(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
+    fn fold_jsx_element_name(
+        &mut self,
+        node: JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_element_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_element_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_element_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_element_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
+    fn fold_jsx_empty_expr(
+        &mut self,
+        node: JSXEmptyExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXEmptyExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_empty_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_empty_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_empty_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_empty_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_expr(&mut self, node: &JSXExpr) {
+    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
+    fn fold_jsx_expr_container(
+        &mut self,
+        node: JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXExprContainer {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_expr_container(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_expr_container(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_expr_container(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_expr_container(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
+    fn fold_jsx_fragment(
+        &mut self,
+        node: JSXFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXFragment {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_fragment(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_fragment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_fragment(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_fragment(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
+    fn fold_jsx_member_expr(
+        &mut self,
+        node: JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXMemberExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_member_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_member_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_member_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_member_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
+    fn fold_jsx_namespaced_name(
+        &mut self,
+        node: JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXNamespacedName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_namespaced_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_namespaced_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_namespaced_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_namespaced_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_object(&mut self, node: &JSXObject) {
+    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_object(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_object(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_object(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_object(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
+    fn fold_jsx_opening_element(
+        &mut self,
+        node: JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningElement {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_opening_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_opening_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_opening_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_opening_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
+    fn fold_jsx_opening_fragment(
+        &mut self,
+        node: JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningFragment {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_opening_fragment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_opening_fragment(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_jsx_opening_fragment(visitor, node)
+                FoldAstPath::fold_jsx_opening_fragment(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
+    fn fold_jsx_spread_child(
+        &mut self,
+        node: JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXSpreadChild {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_spread_child(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_spread_child(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_spread_child(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_spread_child(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_jsx_text(&mut self, node: &JSXText) {
+    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_jsx_text(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_jsx_text(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_jsx_text(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_jsx_text(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_key(&mut self, node: &Key) {
+    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_key(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_key(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_key(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_key(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
+    fn fold_key_value_pat_prop(
+        &mut self,
+        node: KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValuePatProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_key_value_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_key_value_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_key_value_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_key_value_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
+    fn fold_key_value_prop(
+        &mut self,
+        node: KeyValueProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValueProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_key_value_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_key_value_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_key_value_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_key_value_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
+    fn fold_labeled_stmt(
+        &mut self,
+        node: LabeledStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> LabeledStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_labeled_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_labeled_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_labeled_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_labeled_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_lit(&mut self, node: &Lit) {
+    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_lit(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_lit(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_member_expr(&mut self, node: &MemberExpr) {
+    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_member_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_member_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_member_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_member_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_member_prop(&mut self, node: &MemberProp) {
+    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_member_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_member_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_member_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_member_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
+    fn fold_meta_prop_expr(
+        &mut self,
+        node: MetaPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_meta_prop_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_meta_prop_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_meta_prop_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_meta_prop_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
+    fn fold_meta_prop_kind(
+        &mut self,
+        node: MetaPropKind,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropKind {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_meta_prop_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_meta_prop_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_meta_prop_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_meta_prop_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_method_kind(&mut self, node: &MethodKind) {
+    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_method_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_method_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_method_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_method_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_method_prop(&mut self, node: &MethodProp) {
+    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_method_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_method_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_method_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_method_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_module(&mut self, node: &Module) {
+    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_module(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_module(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_module(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_module(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_module_decl(&mut self, node: &ModuleDecl) {
+    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_module_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_module_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_module_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_module_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_module_export_name(&mut self, node: &ModuleExportName) {
+    fn fold_module_export_name(
+        &mut self,
+        node: ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) -> ModuleExportName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_module_export_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_module_export_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_module_export_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_module_export_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_module_item(&mut self, node: &ModuleItem) {
+    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_module_item(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_module_item(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_module_item(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_module_item(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_module_items(&mut self, node: &[ModuleItem]) {
+    fn fold_module_items(
+        &mut self,
+        node: Vec<ModuleItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ModuleItem> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_module_items(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_module_items(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_module_items(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_module_items(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_named_export(&mut self, node: &NamedExport) {
+    fn fold_named_export(
+        &mut self,
+        node: NamedExport,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedExport {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_named_export(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_named_export(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_named_export(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_named_export(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_new_expr(&mut self, node: &NewExpr) {
+    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_new_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_new_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_new_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_new_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_null(&mut self, node: &Null) {
+    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_null(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_null(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_null(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_null(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_number(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_number(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_number(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_number(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_object_lit(&mut self, node: &ObjectLit) {
+    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_object_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_object_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_object_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_object_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_object_pat(&mut self, node: &ObjectPat) {
+    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_object_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_object_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_object_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_object_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
+    fn fold_object_pat_prop(
+        &mut self,
+        node: ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ObjectPatProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_object_pat_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_object_pat_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_object_pat_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_object_pat_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
+    fn fold_object_pat_props(
+        &mut self,
+        node: Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ObjectPatProp> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_object_pat_props(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_object_pat_props(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_object_pat_props(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_object_pat_props(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
+    fn fold_opt_accessibility(
+        &mut self,
+        node: Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Accessibility> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_accessibility(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_accessibility(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_accessibility(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_accessibility(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_atom(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_atom(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>) {
+    fn fold_opt_block_stmt(
+        &mut self,
+        node: Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<BlockStmt> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_block_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_block_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_block_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_block_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_call(&mut self, node: &OptCall) {
+    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_call(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_call(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_call(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_call(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>) {
+    fn fold_opt_catch_clause(
+        &mut self,
+        node: Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<CatchClause> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_catch_clause(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_catch_clause(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_catch_clause(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_catch_clause(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
+    fn fold_opt_chain_base(
+        &mut self,
+        node: OptChainBase,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainBase {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_chain_base(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_chain_base(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_chain_base(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_chain_base(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
+    fn fold_opt_chain_expr(
+        &mut self,
+        node: OptChainExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_chain_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_chain_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_chain_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_chain_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>) {
+    fn fold_opt_expr(
+        &mut self,
+        node: Option<Box<Expr>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Expr>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>) {
+    fn fold_opt_expr_or_spread(
+        &mut self,
+        node: Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ExprOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_expr_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_expr_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_expr_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_expr_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>) {
+    fn fold_opt_expr_or_spreads(
+        &mut self,
+        node: Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<ExprOrSpread>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_expr_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_expr_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_expr_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_expr_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_ident(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_ident(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_ident(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>) {
+    fn fold_opt_jsx_attr_value(
+        &mut self,
+        node: Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXAttrValue> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_jsx_attr_value(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_jsx_attr_value(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_jsx_attr_value(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_jsx_attr_value(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>) {
+    fn fold_opt_jsx_closing_element(
+        &mut self,
+        node: Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXClosingElement> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_jsx_closing_element(visitor, node)
+                FoldAstPath::fold_opt_jsx_closing_element(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_jsx_closing_element(visitor, node)
+                FoldAstPath::fold_opt_jsx_closing_element(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_module_export_name(&mut self, node: &Option<ModuleExportName>) {
+    fn fold_opt_module_export_name(
+        &mut self,
+        node: Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ModuleExportName> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_module_export_name(visitor, node)
+                FoldAstPath::fold_opt_module_export_name(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_module_export_name(visitor, node)
+                FoldAstPath::fold_opt_module_export_name(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_object_lit(&mut self, node: &Option<Box<ObjectLit>>) {
+    fn fold_opt_object_lit(
+        &mut self,
+        node: Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ObjectLit>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_object_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_object_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_object_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_object_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_pat(&mut self, node: &Option<Pat>) {
+    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_span(&mut self, node: &Option<swc_common::Span>) {
+    fn fold_opt_span(
+        &mut self,
+        node: Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_common::Span> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_span(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_span(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_span(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>) {
+    fn fold_opt_stmt(
+        &mut self,
+        node: Option<Box<Stmt>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Stmt>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_str(&mut self, node: &Option<Box<Str>>) {
+    fn fold_opt_str(
+        &mut self,
+        node: Option<Box<Str>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Str>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_str(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_str(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_str(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_str(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>) {
+    fn fold_opt_true_plus_minus(
+        &mut self,
+        node: Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TruePlusMinus> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_true_plus_minus(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_true_plus_minus(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_true_plus_minus(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_true_plus_minus(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>) {
+    fn fold_opt_ts_entity_name(
+        &mut self,
+        node: Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsEntityName> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_ts_entity_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_ts_entity_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_ts_entity_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_ts_entity_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>) {
+    fn fold_opt_ts_namespace_body(
+        &mut self,
+        node: Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsNamespaceBody> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_ts_namespace_body(visitor, node)
+                FoldAstPath::fold_opt_ts_namespace_body(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_ts_namespace_body(visitor, node)
+                FoldAstPath::fold_opt_ts_namespace_body(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>) {
+    fn fold_opt_ts_type(
+        &mut self,
+        node: Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsType>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_ts_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_ts_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_ts_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_ts_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>) {
+    fn fold_opt_ts_type_ann(
+        &mut self,
+        node: Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeAnn>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_ts_type_ann(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_ts_type_ann(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_ts_type_ann(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_ts_type_ann(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_decl(&mut self, node: &Option<Box<TsTypeParamDecl>>) {
+    fn fold_opt_ts_type_param_decl(
+        &mut self,
+        node: Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamDecl>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_ts_type_param_decl(visitor, node)
+                FoldAstPath::fold_opt_ts_type_param_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_ts_type_param_decl(visitor, node)
+                FoldAstPath::fold_opt_ts_type_param_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_instantiation(
+    fn fold_opt_ts_type_param_instantiation(
         &mut self,
-        node: &Option<Box<TsTypeParamInstantiation>>,
-    ) {
+        node: Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamInstantiation>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_ts_type_param_instantiation(visitor, node)
+                FoldAstPath::fold_opt_ts_type_param_instantiation(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_ts_type_param_instantiation(visitor, node)
+                FoldAstPath::fold_opt_ts_type_param_instantiation(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>) {
+    fn fold_opt_var_decl_or_expr(
+        &mut self,
+        node: Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<VarDeclOrExpr> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_var_decl_or_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_var_decl_or_expr(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_var_decl_or_expr(visitor, node)
+                FoldAstPath::fold_opt_var_decl_or_expr(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>]) {
+    fn fold_opt_vec_expr_or_spreads(
+        &mut self,
+        node: Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<ExprOrSpread>> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_vec_expr_or_spreads(visitor, node)
+                FoldAstPath::fold_opt_vec_expr_or_spreads(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_vec_expr_or_spreads(visitor, node)
+                FoldAstPath::fold_opt_vec_expr_or_spreads(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>]) {
+    fn fold_opt_vec_pats(
+        &mut self,
+        node: Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<Pat>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_vec_pats(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_vec_pats(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_opt_vec_pats(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_opt_vec_pats(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_param(&mut self, node: &Param) {
+    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_param(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_param(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_param(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_param(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp) {
+    fn fold_param_or_ts_param_prop(
+        &mut self,
+        node: ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ParamOrTsParamProp {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_param_or_ts_param_prop(visitor, node)
+                FoldAstPath::fold_param_or_ts_param_prop(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_param_or_ts_param_prop(visitor, node)
+                FoldAstPath::fold_param_or_ts_param_prop(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp]) {
+    fn fold_param_or_ts_param_props(
+        &mut self,
+        node: Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ParamOrTsParamProp> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_param_or_ts_param_props(visitor, node)
+                FoldAstPath::fold_param_or_ts_param_props(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_param_or_ts_param_props(visitor, node)
+                FoldAstPath::fold_param_or_ts_param_props(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_params(&mut self, node: &[Param]) {
+    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_params(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_params(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_params(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_paren_expr(&mut self, node: &ParenExpr) {
+    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_paren_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_paren_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_paren_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_paren_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_pat(&mut self, node: &Pat) {
+    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_pat(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_pat(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_pats(&mut self, node: &[Pat]) {
+    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_pats(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_pats(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_pats(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_pats(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_private_method(&mut self, node: &PrivateMethod) {
+    fn fold_private_method(
+        &mut self,
+        node: PrivateMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateMethod {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_private_method(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_private_method(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_private_method(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_private_method(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_private_name(&mut self, node: &PrivateName) {
+    fn fold_private_name(
+        &mut self,
+        node: PrivateName,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_private_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_private_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_private_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_private_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_private_prop(&mut self, node: &PrivateProp) {
+    fn fold_private_prop(
+        &mut self,
+        node: PrivateProp,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_private_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_private_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_private_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_private_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_program(&mut self, node: &Program) {
+    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_program(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_program(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_program(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_program(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_prop(&mut self, node: &Prop) {
+    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_prop(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_prop(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_prop_name(&mut self, node: &PropName) {
+    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_prop_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_prop_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_prop_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_prop_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
+    fn fold_prop_or_spread(
+        &mut self,
+        node: PropOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> PropOrSpread {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_prop_or_spread(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_prop_or_spread(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_prop_or_spread(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_prop_or_spread(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
+    fn fold_prop_or_spreads(
+        &mut self,
+        node: Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PropOrSpread> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_prop_or_spreads(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_prop_or_spreads(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_prop_or_spreads(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_prop_or_spreads(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_regex(&mut self, node: &Regex) {
+    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_regex(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_regex(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_regex(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_regex(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_rest_pat(&mut self, node: &RestPat) {
+    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_rest_pat(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_rest_pat(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_rest_pat(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_rest_pat(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_return_stmt(&mut self, node: &ReturnStmt) {
+    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_return_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_return_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_return_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_return_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_script(&mut self, node: &Script) {
+    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_script(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_script(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_script(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_script(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_seq_expr(&mut self, node: &SeqExpr) {
+    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_seq_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_seq_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_seq_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_seq_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_setter_prop(&mut self, node: &SetterProp) {
+    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_setter_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_setter_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_setter_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_setter_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
+    fn fold_simple_assign_target(
+        &mut self,
+        node: SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleAssignTarget {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_simple_assign_target(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_simple_assign_target(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_simple_assign_target(visitor, node)
+                FoldAstPath::fold_simple_assign_target(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_span(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_span(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_spread_element(&mut self, node: &SpreadElement) {
+    fn fold_spread_element(
+        &mut self,
+        node: SpreadElement,
+        __ast_path: &mut AstKindPath,
+    ) -> SpreadElement {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_spread_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_spread_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_spread_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_spread_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_static_block(&mut self, node: &StaticBlock) {
+    fn fold_static_block(
+        &mut self,
+        node: StaticBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> StaticBlock {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_static_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_static_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_static_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_static_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_stmt(&mut self, node: &Stmt) {
+    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_stmt(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_stmt(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_stmts(&mut self, node: &[Stmt]) {
+    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_stmts(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_stmts(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_stmts(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_stmts(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_str(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_str(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_str(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_super(&mut self, node: &Super) {
+    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_super(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_super(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_super(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_super(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_super_prop(&mut self, node: &SuperProp) {
+    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_super_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_super_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_super_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_super_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
+    fn fold_super_prop_expr(
+        &mut self,
+        node: SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> SuperPropExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_super_prop_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_super_prop_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_super_prop_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_super_prop_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_switch_case(&mut self, node: &SwitchCase) {
+    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_switch_case(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_switch_case(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_switch_case(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_switch_case(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
+    fn fold_switch_cases(
+        &mut self,
+        node: Vec<SwitchCase>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SwitchCase> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_switch_cases(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_switch_cases(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_switch_cases(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_switch_cases(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
+    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_switch_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_switch_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_switch_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_switch_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_syntax_context(&mut self, node: &swc_common::SyntaxContext) {
+    fn fold_syntax_context(
+        &mut self,
+        node: swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::SyntaxContext {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_syntax_context(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_syntax_context(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_syntax_context(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_syntax_context(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_tagged_tpl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_tagged_tpl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_tagged_tpl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_tagged_tpl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_this_expr(&mut self, node: &ThisExpr) {
+    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_this_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_this_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_this_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_this_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
+    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_throw_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_throw_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_throw_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_throw_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_tpl(&mut self, node: &Tpl) {
+    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_tpl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_tpl(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_tpl(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => FoldAstPath::fold_tpl(visitor, node, __ast_path),
         }
     }
 
     #[inline]
-    fn visit_tpl_element(&mut self, node: &TplElement) {
+    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_tpl_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_tpl_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_tpl_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_tpl_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_tpl_elements(&mut self, node: &[TplElement]) {
+    fn fold_tpl_elements(
+        &mut self,
+        node: Vec<TplElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TplElement> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_tpl_elements(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_tpl_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_tpl_elements(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_tpl_elements(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
+    fn fold_true_plus_minus(
+        &mut self,
+        node: TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) -> TruePlusMinus {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_true_plus_minus(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_true_plus_minus(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_true_plus_minus(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_true_plus_minus(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_try_stmt(&mut self, node: &TryStmt) {
+    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_try_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_try_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_try_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_try_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_array_type(&mut self, node: &TsArrayType) {
+    fn fold_ts_array_type(
+        &mut self,
+        node: TsArrayType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsArrayType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_array_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_array_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_array_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_array_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_as_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_as_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_as_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_as_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
+    fn fold_ts_call_signature_decl(
+        &mut self,
+        node: TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsCallSignatureDecl {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_call_signature_decl(visitor, node)
+                FoldAstPath::fold_ts_call_signature_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_call_signature_decl(visitor, node)
+                FoldAstPath::fold_ts_call_signature_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
+    fn fold_ts_conditional_type(
+        &mut self,
+        node: TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConditionalType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_conditional_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_conditional_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_conditional_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_conditional_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
+    fn fold_ts_const_assertion(
+        &mut self,
+        node: TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstAssertion {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_const_assertion(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_const_assertion(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_const_assertion(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_const_assertion(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
+    fn fold_ts_construct_signature_decl(
+        &mut self,
+        node: TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructSignatureDecl {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_construct_signature_decl(visitor, node)
+                FoldAstPath::fold_ts_construct_signature_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_construct_signature_decl(visitor, node)
+                FoldAstPath::fold_ts_construct_signature_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
+    fn fold_ts_constructor_type(
+        &mut self,
+        node: TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructorType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_constructor_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_constructor_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_constructor_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_constructor_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
+    fn fold_ts_entity_name(
+        &mut self,
+        node: TsEntityName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEntityName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_entity_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_entity_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_entity_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_entity_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_enum_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_enum_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_enum_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_enum_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
+    fn fold_ts_enum_member(
+        &mut self,
+        node: TsEnumMember,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMember {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_enum_member(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_enum_member(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_enum_member(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_enum_member(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
+    fn fold_ts_enum_member_id(
+        &mut self,
+        node: TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMemberId {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_enum_member_id(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_enum_member_id(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_enum_member_id(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_enum_member_id(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
+    fn fold_ts_enum_members(
+        &mut self,
+        node: Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsEnumMember> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_enum_members(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_enum_members(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_enum_members(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_enum_members(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
+    fn fold_ts_export_assignment(
+        &mut self,
+        node: TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExportAssignment {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_export_assignment(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_export_assignment(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_export_assignment(visitor, node)
+                FoldAstPath::fold_ts_export_assignment(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs) {
+    fn fold_ts_expr_with_type_args(
+        &mut self,
+        node: TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExprWithTypeArgs {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_expr_with_type_args(visitor, node)
+                FoldAstPath::fold_ts_expr_with_type_args(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_expr_with_type_args(visitor, node)
+                FoldAstPath::fold_ts_expr_with_type_args(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs]) {
+    fn fold_ts_expr_with_type_argss(
+        &mut self,
+        node: Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsExprWithTypeArgs> {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_expr_with_type_argss(visitor, node)
+                FoldAstPath::fold_ts_expr_with_type_argss(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_expr_with_type_argss(visitor, node)
+                FoldAstPath::fold_ts_expr_with_type_argss(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
+    fn fold_ts_external_module_ref(
+        &mut self,
+        node: TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExternalModuleRef {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_external_module_ref(visitor, node)
+                FoldAstPath::fold_ts_external_module_ref(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_external_module_ref(visitor, node)
+                FoldAstPath::fold_ts_external_module_ref(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType) {
+    fn fold_ts_fn_or_constructor_type(
+        &mut self,
+        node: TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsFnOrConstructorType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_fn_or_constructor_type(visitor, node)
+                FoldAstPath::fold_ts_fn_or_constructor_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_fn_or_constructor_type(visitor, node)
+                FoldAstPath::fold_ts_fn_or_constructor_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
+    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_fn_param(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_fn_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_fn_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_fn_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
+    fn fold_ts_fn_params(
+        &mut self,
+        node: Vec<TsFnParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsFnParam> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_fn_params(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_fn_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_fn_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_fn_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_fn_type(&mut self, node: &TsFnType) {
+    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_fn_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_fn_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_fn_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_fn_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
+    fn fold_ts_getter_signature(
+        &mut self,
+        node: TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsGetterSignature {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_getter_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_getter_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_getter_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_getter_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
+    fn fold_ts_import_equals_decl(
+        &mut self,
+        node: TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportEqualsDecl {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_import_equals_decl(visitor, node)
+                FoldAstPath::fold_ts_import_equals_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_import_equals_decl(visitor, node)
+                FoldAstPath::fold_ts_import_equals_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_import_type(&mut self, node: &TsImportType) {
+    fn fold_ts_import_type(
+        &mut self,
+        node: TsImportType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_import_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_import_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_import_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_import_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
+    fn fold_ts_index_signature(
+        &mut self,
+        node: TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexSignature {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_index_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_index_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_index_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_index_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
+    fn fold_ts_indexed_access_type(
+        &mut self,
+        node: TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexedAccessType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_indexed_access_type(visitor, node)
+                FoldAstPath::fold_ts_indexed_access_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_indexed_access_type(visitor, node)
+                FoldAstPath::fold_ts_indexed_access_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_infer_type(&mut self, node: &TsInferType) {
+    fn fold_ts_infer_type(
+        &mut self,
+        node: TsInferType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInferType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_infer_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_infer_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_infer_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_infer_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
+    fn fold_ts_instantiation(
+        &mut self,
+        node: TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInstantiation {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_instantiation(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_instantiation(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_instantiation(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_instantiation(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
+    fn fold_ts_interface_body(
+        &mut self,
+        node: TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceBody {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_interface_body(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_interface_body(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_interface_body(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_interface_body(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
+    fn fold_ts_interface_decl(
+        &mut self,
+        node: TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_interface_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_interface_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_interface_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_interface_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
+    fn fold_ts_intersection_type(
+        &mut self,
+        node: TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIntersectionType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_intersection_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_intersection_type(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_intersection_type(visitor, node)
+                FoldAstPath::fold_ts_intersection_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
+    fn fold_ts_keyword_type(
+        &mut self,
+        node: TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_keyword_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_keyword_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_keyword_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_keyword_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
+    fn fold_ts_keyword_type_kind(
+        &mut self,
+        node: TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordTypeKind {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_keyword_type_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_keyword_type_kind(visitor, node, __ast_path)
+            }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_keyword_type_kind(visitor, node)
+                FoldAstPath::fold_ts_keyword_type_kind(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_lit(&mut self, node: &TsLit) {
+    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => FoldAstPath::fold_ts_lit(visitor, node, __ast_path),
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_lit_type(&mut self, node: &TsLitType) {
+    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_lit_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_lit_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_lit_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_lit_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
+    fn fold_ts_mapped_type(
+        &mut self,
+        node: TsMappedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMappedType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_mapped_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_mapped_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_mapped_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_mapped_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
+    fn fold_ts_method_signature(
+        &mut self,
+        node: TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMethodSignature {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_method_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_method_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_method_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_method_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
+    fn fold_ts_module_block(
+        &mut self,
+        node: TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleBlock {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_module_block(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_module_block(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_module_block(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_module_block(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
+    fn fold_ts_module_decl(
+        &mut self,
+        node: TsModuleDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_module_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_module_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_module_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_module_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_module_name(&mut self, node: &TsModuleName) {
+    fn fold_ts_module_name(
+        &mut self,
+        node: TsModuleName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_module_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_module_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_module_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_module_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
+    fn fold_ts_module_ref(
+        &mut self,
+        node: TsModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleRef {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_module_ref(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_module_ref(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_module_ref(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_module_ref(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
+    fn fold_ts_namespace_body(
+        &mut self,
+        node: TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceBody {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_namespace_body(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_namespace_body(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_namespace_body(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_namespace_body(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
+    fn fold_ts_namespace_decl(
+        &mut self,
+        node: TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_namespace_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_namespace_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_namespace_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_namespace_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
+    fn fold_ts_namespace_export_decl(
+        &mut self,
+        node: TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceExportDecl {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_namespace_export_decl(visitor, node)
+                FoldAstPath::fold_ts_namespace_export_decl(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_namespace_export_decl(visitor, node)
+                FoldAstPath::fold_ts_namespace_export_decl(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
+    fn fold_ts_non_null_expr(
+        &mut self,
+        node: TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNonNullExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_non_null_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_non_null_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_non_null_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_non_null_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
+    fn fold_ts_optional_type(
+        &mut self,
+        node: TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsOptionalType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_optional_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_optional_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_optional_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_optional_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
+    fn fold_ts_param_prop(
+        &mut self,
+        node: TsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamProp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_param_prop(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_param_prop(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_param_prop(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_param_prop(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
+    fn fold_ts_param_prop_param(
+        &mut self,
+        node: TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamPropParam {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_param_prop_param(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_param_prop_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_param_prop_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_param_prop_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
+    fn fold_ts_parenthesized_type(
+        &mut self,
+        node: TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParenthesizedType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_parenthesized_type(visitor, node)
+                FoldAstPath::fold_ts_parenthesized_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_parenthesized_type(visitor, node)
+                FoldAstPath::fold_ts_parenthesized_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
+    fn fold_ts_property_signature(
+        &mut self,
+        node: TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsPropertySignature {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_property_signature(visitor, node)
+                FoldAstPath::fold_ts_property_signature(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_property_signature(visitor, node)
+                FoldAstPath::fold_ts_property_signature(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
+    fn fold_ts_qualified_name(
+        &mut self,
+        node: TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsQualifiedName {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_qualified_name(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_qualified_name(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_qualified_name(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_qualified_name(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_rest_type(&mut self, node: &TsRestType) {
+    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_rest_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_rest_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_rest_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_rest_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
+    fn fold_ts_satisfies_expr(
+        &mut self,
+        node: TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSatisfiesExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_satisfies_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_satisfies_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_satisfies_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_satisfies_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
+    fn fold_ts_setter_signature(
+        &mut self,
+        node: TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSetterSignature {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_setter_signature(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_setter_signature(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_setter_signature(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_setter_signature(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_this_type(&mut self, node: &TsThisType) {
+    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_this_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_this_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_this_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_this_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent) {
+    fn fold_ts_this_type_or_ident(
+        &mut self,
+        node: TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> TsThisTypeOrIdent {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_this_type_or_ident(visitor, node)
+                FoldAstPath::fold_ts_this_type_or_ident(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_this_type_or_ident(visitor, node)
+                FoldAstPath::fold_ts_this_type_or_ident(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
+    fn fold_ts_tpl_lit_type(
+        &mut self,
+        node: TsTplLitType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTplLitType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_tpl_lit_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_tpl_lit_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_tpl_lit_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_tpl_lit_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
+    fn fold_ts_tuple_element(
+        &mut self,
+        node: TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleElement {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_tuple_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_tuple_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_tuple_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_tuple_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
+    fn fold_ts_tuple_elements(
+        &mut self,
+        node: Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTupleElement> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_tuple_elements(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_tuple_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_tuple_elements(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_tuple_elements(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
+    fn fold_ts_tuple_type(
+        &mut self,
+        node: TsTupleType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_tuple_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_tuple_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_tuple_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_tuple_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type(&mut self, node: &TsType) {
+    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
+    fn fold_ts_type_alias_decl(
+        &mut self,
+        node: TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAliasDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_alias_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_alias_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_alias_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_alias_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_ann(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_ann(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_ann(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_ann(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
+    fn fold_ts_type_assertion(
+        &mut self,
+        node: TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAssertion {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_assertion(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_assertion(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_assertion(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_assertion(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
+    fn fold_ts_type_element(
+        &mut self,
+        node: TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeElement {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_element(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_element(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_element(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
+    fn fold_ts_type_elements(
+        &mut self,
+        node: Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeElement> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_elements(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_elements(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_elements(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_elements(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_lit(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_lit(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_lit(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_lit(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
+    fn fold_ts_type_operator(
+        &mut self,
+        node: TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperator {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_operator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_operator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_operator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_operator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
+    fn fold_ts_type_operator_op(
+        &mut self,
+        node: TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperatorOp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_operator_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_operator_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_operator_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_operator_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
+    fn fold_ts_type_param(
+        &mut self,
+        node: TsTypeParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParam {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_param(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_param(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_param(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_param(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
+    fn fold_ts_type_param_decl(
+        &mut self,
+        node: TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_param_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_param_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_param_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_param_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
+    fn fold_ts_type_param_instantiation(
+        &mut self,
+        node: TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamInstantiation {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_type_param_instantiation(visitor, node)
+                FoldAstPath::fold_ts_type_param_instantiation(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_type_param_instantiation(visitor, node)
+                FoldAstPath::fold_ts_type_param_instantiation(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
+    fn fold_ts_type_params(
+        &mut self,
+        node: Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeParam> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_params(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_params(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_params(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_params(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
+    fn fold_ts_type_predicate(
+        &mut self,
+        node: TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypePredicate {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_predicate(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_predicate(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_predicate(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_predicate(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
+    fn fold_ts_type_query(
+        &mut self,
+        node: TsTypeQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQuery {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_query(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_query(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_query(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_query(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
+    fn fold_ts_type_query_expr(
+        &mut self,
+        node: TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQueryExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_query_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_query_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_query_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_query_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_type_ref(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_type_ref(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_type_ref(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_type_ref(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
+    fn fold_ts_types(
+        &mut self,
+        node: Vec<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Box<TsType>> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_types(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_types(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_types(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_types(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_ts_union_or_intersection_type(&mut self, node: &TsUnionOrIntersectionType) {
+    fn fold_ts_union_or_intersection_type(
+        &mut self,
+        node: TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionOrIntersectionType {
         match self {
             swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_ts_union_or_intersection_type(visitor, node)
+                FoldAstPath::fold_ts_union_or_intersection_type(visitor, node, __ast_path)
             }
             swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_ts_union_or_intersection_type(visitor, node)
+                FoldAstPath::fold_ts_union_or_intersection_type(visitor, node, __ast_path)
             }
         }
     }
 
     #[inline]
-    fn visit_ts_union_type(&mut self, node: &TsUnionType) {
+    fn fold_ts_union_type(
+        &mut self,
+        node: TsUnionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionType {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_ts_union_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_ts_union_type(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_ts_union_type(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_ts_union_type(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_unary_expr(&mut self, node: &UnaryExpr) {
+    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_unary_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_unary_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_unary_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_unary_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_unary_op(&mut self, node: &UnaryOp) {
+    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_unary_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_unary_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_unary_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_unary_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_update_expr(&mut self, node: &UpdateExpr) {
+    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_update_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_update_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_update_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_update_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_update_op(&mut self, node: &UpdateOp) {
+    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_update_op(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_update_op(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_update_op(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_update_op(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_using_decl(&mut self, node: &UsingDecl) {
+    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_using_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_using_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_using_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_using_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_var_decl(&mut self, node: &VarDecl) {
+    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_var_decl(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_var_decl(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_var_decl(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_var_decl(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
+    fn fold_var_decl_kind(
+        &mut self,
+        node: VarDeclKind,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclKind {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_var_decl_kind(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_var_decl_kind(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_var_decl_kind(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_var_decl_kind(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
+    fn fold_var_decl_or_expr(
+        &mut self,
+        node: VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclOrExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_var_decl_or_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_var_decl_or_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_var_decl_or_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_var_decl_or_expr(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_var_declarator(&mut self, node: &VarDeclarator) {
+    fn fold_var_declarator(
+        &mut self,
+        node: VarDeclarator,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclarator {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_var_declarator(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_var_declarator(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_var_declarator(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_var_declarator(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
+    fn fold_var_declarators(
+        &mut self,
+        node: Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<VarDeclarator> {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_var_declarators(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_var_declarators(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_var_declarators(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_var_declarators(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_while_stmt(&mut self, node: &WhileStmt) {
+    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_while_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_while_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_while_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_while_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_with_stmt(&mut self, node: &WithStmt) {
+    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_with_stmt(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_with_stmt(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_with_stmt(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_with_stmt(visitor, node, __ast_path)
+            }
         }
     }
 
     #[inline]
-    fn visit_yield_expr(&mut self, node: &YieldExpr) {
+    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
         match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_yield_expr(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_yield_expr(visitor, node),
+            swc_visit::Either::Left(visitor) => {
+                FoldAstPath::fold_yield_expr(visitor, node, __ast_path)
+            }
+            swc_visit::Either::Right(visitor) => {
+                FoldAstPath::fold_yield_expr(visitor, node, __ast_path)
+            }
         }
     }
 }
-impl<V> VisitAll for ::swc_visit::Optional<V>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V> FoldAstPath for ::swc_visit::Optional<V>
 where
-    V: VisitAll,
+    V: FoldAstPath,
 {
     #[inline]
-    fn visit_accessibility(&mut self, node: &Accessibility) {
+    fn fold_accessibility(
+        &mut self,
+        node: Accessibility,
+        __ast_path: &mut AstKindPath,
+    ) -> Accessibility {
         if self.enabled {
-            <V as VisitAll>::visit_accessibility(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_accessibility(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_array_lit(&mut self, node: &ArrayLit) {
+    fn fold_array_lit(&mut self, node: ArrayLit, __ast_path: &mut AstKindPath) -> ArrayLit {
         if self.enabled {
-            <V as VisitAll>::visit_array_lit(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_array_lit(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_array_pat(&mut self, node: &ArrayPat) {
+    fn fold_array_pat(&mut self, node: ArrayPat, __ast_path: &mut AstKindPath) -> ArrayPat {
         if self.enabled {
-            <V as VisitAll>::visit_array_pat(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_array_pat(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
+    fn fold_arrow_expr(&mut self, node: ArrowExpr, __ast_path: &mut AstKindPath) -> ArrowExpr {
         if self.enabled {
-            <V as VisitAll>::visit_arrow_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_arrow_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_assign_expr(&mut self, node: &AssignExpr) {
+    fn fold_assign_expr(&mut self, node: AssignExpr, __ast_path: &mut AstKindPath) -> AssignExpr {
         if self.enabled {
-            <V as VisitAll>::visit_assign_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_assign_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_assign_op(&mut self, node: &AssignOp) {
+    fn fold_assign_op(&mut self, node: AssignOp, __ast_path: &mut AstKindPath) -> AssignOp {
         if self.enabled {
-            <V as VisitAll>::visit_assign_op(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_assign_op(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_assign_pat(&mut self, node: &AssignPat) {
+    fn fold_assign_pat(&mut self, node: AssignPat, __ast_path: &mut AstKindPath) -> AssignPat {
         if self.enabled {
-            <V as VisitAll>::visit_assign_pat(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_assign_pat(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
+    fn fold_assign_pat_prop(
+        &mut self,
+        node: AssignPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignPatProp {
         if self.enabled {
-            <V as VisitAll>::visit_assign_pat_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_assign_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_assign_prop(&mut self, node: &AssignProp) {
+    fn fold_assign_prop(&mut self, node: AssignProp, __ast_path: &mut AstKindPath) -> AssignProp {
         if self.enabled {
-            <V as VisitAll>::visit_assign_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_assign_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_assign_target(&mut self, node: &AssignTarget) {
+    fn fold_assign_target(
+        &mut self,
+        node: AssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTarget {
         if self.enabled {
-            <V as VisitAll>::visit_assign_target(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_assign_target(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
+    fn fold_assign_target_pat(
+        &mut self,
+        node: AssignTargetPat,
+        __ast_path: &mut AstKindPath,
+    ) -> AssignTargetPat {
         if self.enabled {
-            <V as VisitAll>::visit_assign_target_pat(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_assign_target_pat(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
+    fn fold_atom(
+        &mut self,
+        node: swc_atoms::Atom,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_atoms::Atom {
         if self.enabled {
-            <V as VisitAll>::visit_atom(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_atom(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
+    fn fold_auto_accessor(
+        &mut self,
+        node: AutoAccessor,
+        __ast_path: &mut AstKindPath,
+    ) -> AutoAccessor {
         if self.enabled {
-            <V as VisitAll>::visit_auto_accessor(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_auto_accessor(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_await_expr(&mut self, node: &AwaitExpr) {
+    fn fold_await_expr(&mut self, node: AwaitExpr, __ast_path: &mut AstKindPath) -> AwaitExpr {
         if self.enabled {
-            <V as VisitAll>::visit_await_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_await_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_big_int(&mut self, node: &BigInt) {
+    fn fold_big_int(&mut self, node: BigInt, __ast_path: &mut AstKindPath) -> BigInt {
         if self.enabled {
-            <V as VisitAll>::visit_big_int(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_big_int(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_big_int_value(&mut self, node: &BigIntValue) {
+    fn fold_big_int_value(
+        &mut self,
+        node: BigIntValue,
+        __ast_path: &mut AstKindPath,
+    ) -> BigIntValue {
         if self.enabled {
-            <V as VisitAll>::visit_big_int_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_big_int_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_bin_expr(&mut self, node: &BinExpr) {
+    fn fold_bin_expr(&mut self, node: BinExpr, __ast_path: &mut AstKindPath) -> BinExpr {
         if self.enabled {
-            <V as VisitAll>::visit_bin_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_bin_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_binary_op(&mut self, node: &BinaryOp) {
+    fn fold_binary_op(&mut self, node: BinaryOp, __ast_path: &mut AstKindPath) -> BinaryOp {
         if self.enabled {
-            <V as VisitAll>::visit_binary_op(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_binary_op(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_binding_ident(&mut self, node: &BindingIdent) {
+    fn fold_binding_ident(
+        &mut self,
+        node: BindingIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> BindingIdent {
         if self.enabled {
-            <V as VisitAll>::visit_binding_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_binding_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_block_stmt(&mut self, node: &BlockStmt) {
+    fn fold_block_stmt(&mut self, node: BlockStmt, __ast_path: &mut AstKindPath) -> BlockStmt {
         if self.enabled {
-            <V as VisitAll>::visit_block_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_block_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
+    fn fold_block_stmt_or_expr(
+        &mut self,
+        node: BlockStmtOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> BlockStmtOrExpr {
         if self.enabled {
-            <V as VisitAll>::visit_block_stmt_or_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_block_stmt_or_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_bool(&mut self, node: &Bool) {
+    fn fold_bool(&mut self, node: Bool, __ast_path: &mut AstKindPath) -> Bool {
         if self.enabled {
-            <V as VisitAll>::visit_bool(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_bool(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_break_stmt(&mut self, node: &BreakStmt) {
+    fn fold_break_stmt(&mut self, node: BreakStmt, __ast_path: &mut AstKindPath) -> BreakStmt {
         if self.enabled {
-            <V as VisitAll>::visit_break_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_break_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_call_expr(&mut self, node: &CallExpr) {
+    fn fold_call_expr(&mut self, node: CallExpr, __ast_path: &mut AstKindPath) -> CallExpr {
         if self.enabled {
-            <V as VisitAll>::visit_call_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_call_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_callee(&mut self, node: &Callee) {
+    fn fold_callee(&mut self, node: Callee, __ast_path: &mut AstKindPath) -> Callee {
         if self.enabled {
-            <V as VisitAll>::visit_callee(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_callee(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_catch_clause(&mut self, node: &CatchClause) {
+    fn fold_catch_clause(
+        &mut self,
+        node: CatchClause,
+        __ast_path: &mut AstKindPath,
+    ) -> CatchClause {
         if self.enabled {
-            <V as VisitAll>::visit_catch_clause(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_catch_clause(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class(&mut self, node: &Class) {
+    fn fold_class(&mut self, node: Class, __ast_path: &mut AstKindPath) -> Class {
         if self.enabled {
-            <V as VisitAll>::visit_class(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class_decl(&mut self, node: &ClassDecl) {
+    fn fold_class_decl(&mut self, node: ClassDecl, __ast_path: &mut AstKindPath) -> ClassDecl {
         if self.enabled {
-            <V as VisitAll>::visit_class_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class_expr(&mut self, node: &ClassExpr) {
+    fn fold_class_expr(&mut self, node: ClassExpr, __ast_path: &mut AstKindPath) -> ClassExpr {
         if self.enabled {
-            <V as VisitAll>::visit_class_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class_member(&mut self, node: &ClassMember) {
+    fn fold_class_member(
+        &mut self,
+        node: ClassMember,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMember {
         if self.enabled {
-            <V as VisitAll>::visit_class_member(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class_member(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class_members(&mut self, node: &[ClassMember]) {
+    fn fold_class_members(
+        &mut self,
+        node: Vec<ClassMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ClassMember> {
         if self.enabled {
-            <V as VisitAll>::visit_class_members(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class_members(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class_method(&mut self, node: &ClassMethod) {
+    fn fold_class_method(
+        &mut self,
+        node: ClassMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> ClassMethod {
         if self.enabled {
-            <V as VisitAll>::visit_class_method(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class_method(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_class_prop(&mut self, node: &ClassProp) {
+    fn fold_class_prop(&mut self, node: ClassProp, __ast_path: &mut AstKindPath) -> ClassProp {
         if self.enabled {
-            <V as VisitAll>::visit_class_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_class_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
+    fn fold_computed_prop_name(
+        &mut self,
+        node: ComputedPropName,
+        __ast_path: &mut AstKindPath,
+    ) -> ComputedPropName {
         if self.enabled {
-            <V as VisitAll>::visit_computed_prop_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_computed_prop_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_cond_expr(&mut self, node: &CondExpr) {
+    fn fold_cond_expr(&mut self, node: CondExpr, __ast_path: &mut AstKindPath) -> CondExpr {
         if self.enabled {
-            <V as VisitAll>::visit_cond_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_cond_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_constructor(&mut self, node: &Constructor) {
+    fn fold_constructor(&mut self, node: Constructor, __ast_path: &mut AstKindPath) -> Constructor {
         if self.enabled {
-            <V as VisitAll>::visit_constructor(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_constructor(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
+    fn fold_continue_stmt(
+        &mut self,
+        node: ContinueStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> ContinueStmt {
         if self.enabled {
-            <V as VisitAll>::visit_continue_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_continue_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
+    fn fold_debugger_stmt(
+        &mut self,
+        node: DebuggerStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DebuggerStmt {
         if self.enabled {
-            <V as VisitAll>::visit_debugger_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_debugger_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_decl(&mut self, node: &Decl) {
+    fn fold_decl(&mut self, node: Decl, __ast_path: &mut AstKindPath) -> Decl {
         if self.enabled {
-            <V as VisitAll>::visit_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_decorator(&mut self, node: &Decorator) {
+    fn fold_decorator(&mut self, node: Decorator, __ast_path: &mut AstKindPath) -> Decorator {
         if self.enabled {
-            <V as VisitAll>::visit_decorator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_decorator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_decorators(&mut self, node: &[Decorator]) {
+    fn fold_decorators(
+        &mut self,
+        node: Vec<Decorator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Decorator> {
         if self.enabled {
-            <V as VisitAll>::visit_decorators(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_decorators(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_default_decl(&mut self, node: &DefaultDecl) {
+    fn fold_default_decl(
+        &mut self,
+        node: DefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> DefaultDecl {
         if self.enabled {
-            <V as VisitAll>::visit_default_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_default_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
+    fn fold_do_while_stmt(
+        &mut self,
+        node: DoWhileStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> DoWhileStmt {
         if self.enabled {
-            <V as VisitAll>::visit_do_while_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_do_while_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
+    fn fold_empty_stmt(&mut self, node: EmptyStmt, __ast_path: &mut AstKindPath) -> EmptyStmt {
         if self.enabled {
-            <V as VisitAll>::visit_empty_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_empty_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_es_version(&mut self, node: &EsVersion) {
+    fn fold_es_version(&mut self, node: EsVersion, __ast_path: &mut AstKindPath) -> EsVersion {
         if self.enabled {
-            <V as VisitAll>::visit_es_version(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_es_version(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_all(&mut self, node: &ExportAll) {
+    fn fold_export_all(&mut self, node: ExportAll, __ast_path: &mut AstKindPath) -> ExportAll {
         if self.enabled {
-            <V as VisitAll>::visit_export_all(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_all(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_decl(&mut self, node: &ExportDecl) {
+    fn fold_export_decl(&mut self, node: ExportDecl, __ast_path: &mut AstKindPath) -> ExportDecl {
         if self.enabled {
-            <V as VisitAll>::visit_export_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
+    fn fold_export_default_decl(
+        &mut self,
+        node: ExportDefaultDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultDecl {
         if self.enabled {
-            <V as VisitAll>::visit_export_default_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_default_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
+    fn fold_export_default_expr(
+        &mut self,
+        node: ExportDefaultExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultExpr {
         if self.enabled {
-            <V as VisitAll>::visit_export_default_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_default_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
+    fn fold_export_default_specifier(
+        &mut self,
+        node: ExportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportDefaultSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_export_default_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_default_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
+    fn fold_export_named_specifier(
+        &mut self,
+        node: ExportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamedSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_export_named_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_named_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
+    fn fold_export_namespace_specifier(
+        &mut self,
+        node: ExportNamespaceSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportNamespaceSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_export_namespace_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_namespace_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
+    fn fold_export_specifier(
+        &mut self,
+        node: ExportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ExportSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_export_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
+    fn fold_export_specifiers(
+        &mut self,
+        node: Vec<ExportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExportSpecifier> {
         if self.enabled {
-            <V as VisitAll>::visit_export_specifiers(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_export_specifiers(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_expr(&mut self, node: &Expr) {
+    fn fold_expr(&mut self, node: Expr, __ast_path: &mut AstKindPath) -> Expr {
         if self.enabled {
-            <V as VisitAll>::visit_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
+    fn fold_expr_or_spread(
+        &mut self,
+        node: ExprOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> ExprOrSpread {
         if self.enabled {
-            <V as VisitAll>::visit_expr_or_spread(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_expr_or_spread(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
+    fn fold_expr_or_spreads(
+        &mut self,
+        node: Vec<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ExprOrSpread> {
         if self.enabled {
-            <V as VisitAll>::visit_expr_or_spreads(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_expr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_expr_stmt(&mut self, node: &ExprStmt) {
+    fn fold_expr_stmt(&mut self, node: ExprStmt, __ast_path: &mut AstKindPath) -> ExprStmt {
         if self.enabled {
-            <V as VisitAll>::visit_expr_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_expr_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_exprs(&mut self, node: &[Box<Expr>]) {
+    fn fold_exprs(&mut self, node: Vec<Box<Expr>>, __ast_path: &mut AstKindPath) -> Vec<Box<Expr>> {
         if self.enabled {
-            <V as VisitAll>::visit_exprs(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_exprs(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_fn_decl(&mut self, node: &FnDecl) {
+    fn fold_fn_decl(&mut self, node: FnDecl, __ast_path: &mut AstKindPath) -> FnDecl {
         if self.enabled {
-            <V as VisitAll>::visit_fn_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_fn_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_fn_expr(&mut self, node: &FnExpr) {
+    fn fold_fn_expr(&mut self, node: FnExpr, __ast_path: &mut AstKindPath) -> FnExpr {
         if self.enabled {
-            <V as VisitAll>::visit_fn_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_fn_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_for_head(&mut self, node: &ForHead) {
+    fn fold_for_head(&mut self, node: ForHead, __ast_path: &mut AstKindPath) -> ForHead {
         if self.enabled {
-            <V as VisitAll>::visit_for_head(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_for_head(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
+    fn fold_for_in_stmt(&mut self, node: ForInStmt, __ast_path: &mut AstKindPath) -> ForInStmt {
         if self.enabled {
-            <V as VisitAll>::visit_for_in_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_for_in_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
+    fn fold_for_of_stmt(&mut self, node: ForOfStmt, __ast_path: &mut AstKindPath) -> ForOfStmt {
         if self.enabled {
-            <V as VisitAll>::visit_for_of_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_for_of_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_for_stmt(&mut self, node: &ForStmt) {
+    fn fold_for_stmt(&mut self, node: ForStmt, __ast_path: &mut AstKindPath) -> ForStmt {
         if self.enabled {
-            <V as VisitAll>::visit_for_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_for_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_function(&mut self, node: &Function) {
+    fn fold_function(&mut self, node: Function, __ast_path: &mut AstKindPath) -> Function {
         if self.enabled {
-            <V as VisitAll>::visit_function(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_function(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_getter_prop(&mut self, node: &GetterProp) {
+    fn fold_getter_prop(&mut self, node: GetterProp, __ast_path: &mut AstKindPath) -> GetterProp {
         if self.enabled {
-            <V as VisitAll>::visit_getter_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_getter_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ident(&mut self, node: &Ident) {
+    fn fold_ident(&mut self, node: Ident, __ast_path: &mut AstKindPath) -> Ident {
         if self.enabled {
-            <V as VisitAll>::visit_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ident_name(&mut self, node: &IdentName) {
+    fn fold_ident_name(&mut self, node: IdentName, __ast_path: &mut AstKindPath) -> IdentName {
         if self.enabled {
-            <V as VisitAll>::visit_ident_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ident_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_if_stmt(&mut self, node: &IfStmt) {
+    fn fold_if_stmt(&mut self, node: IfStmt, __ast_path: &mut AstKindPath) -> IfStmt {
         if self.enabled {
-            <V as VisitAll>::visit_if_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_if_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import(&mut self, node: &Import) {
+    fn fold_import(&mut self, node: Import, __ast_path: &mut AstKindPath) -> Import {
         if self.enabled {
-            <V as VisitAll>::visit_import(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_decl(&mut self, node: &ImportDecl) {
+    fn fold_import_decl(&mut self, node: ImportDecl, __ast_path: &mut AstKindPath) -> ImportDecl {
         if self.enabled {
-            <V as VisitAll>::visit_import_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
+    fn fold_import_default_specifier(
+        &mut self,
+        node: ImportDefaultSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportDefaultSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_import_default_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_default_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
+    fn fold_import_named_specifier(
+        &mut self,
+        node: ImportNamedSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportNamedSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_import_named_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_named_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_phase(&mut self, node: &ImportPhase) {
+    fn fold_import_phase(
+        &mut self,
+        node: ImportPhase,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportPhase {
         if self.enabled {
-            <V as VisitAll>::visit_import_phase(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_phase(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
+    fn fold_import_specifier(
+        &mut self,
+        node: ImportSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_import_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
+    fn fold_import_specifiers(
+        &mut self,
+        node: Vec<ImportSpecifier>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportSpecifier> {
         if self.enabled {
-            <V as VisitAll>::visit_import_specifiers(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_specifiers(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
+    fn fold_import_star_as_specifier(
+        &mut self,
+        node: ImportStarAsSpecifier,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportStarAsSpecifier {
         if self.enabled {
-            <V as VisitAll>::visit_import_star_as_specifier(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_star_as_specifier(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_with(&mut self, node: &ImportWith) {
+    fn fold_import_with(&mut self, node: ImportWith, __ast_path: &mut AstKindPath) -> ImportWith {
         if self.enabled {
-            <V as VisitAll>::visit_import_with(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_with(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_with_item(&mut self, node: &ImportWithItem) {
+    fn fold_import_with_item(
+        &mut self,
+        node: ImportWithItem,
+        __ast_path: &mut AstKindPath,
+    ) -> ImportWithItem {
         if self.enabled {
-            <V as VisitAll>::visit_import_with_item(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_with_item(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
+    fn fold_import_with_items(
+        &mut self,
+        node: Vec<ImportWithItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ImportWithItem> {
         if self.enabled {
-            <V as VisitAll>::visit_import_with_items(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_import_with_items(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_invalid(&mut self, node: &Invalid) {
+    fn fold_invalid(&mut self, node: Invalid, __ast_path: &mut AstKindPath) -> Invalid {
         if self.enabled {
-            <V as VisitAll>::visit_invalid(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_invalid(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_attr(&mut self, node: &JSXAttr) {
+    fn fold_jsx_attr(&mut self, node: JSXAttr, __ast_path: &mut AstKindPath) -> JSXAttr {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_attr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_attr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
+    fn fold_jsx_attr_name(
+        &mut self,
+        node: JSXAttrName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrName {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_attr_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_attr_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
+    fn fold_jsx_attr_or_spread(
+        &mut self,
+        node: JSXAttrOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrOrSpread {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_attr_or_spread(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_attr_or_spread(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
+    fn fold_jsx_attr_or_spreads(
+        &mut self,
+        node: Vec<JSXAttrOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXAttrOrSpread> {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_attr_or_spreads(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_attr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
+    fn fold_jsx_attr_value(
+        &mut self,
+        node: JSXAttrValue,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXAttrValue {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_attr_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_attr_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
+    fn fold_jsx_closing_element(
+        &mut self,
+        node: JSXClosingElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingElement {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_closing_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_closing_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
+    fn fold_jsx_closing_fragment(
+        &mut self,
+        node: JSXClosingFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXClosingFragment {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_closing_fragment(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_closing_fragment(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_element(&mut self, node: &JSXElement) {
+    fn fold_jsx_element(&mut self, node: JSXElement, __ast_path: &mut AstKindPath) -> JSXElement {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
+    fn fold_jsx_element_child(
+        &mut self,
+        node: JSXElementChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementChild {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_element_child(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_element_child(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
+    fn fold_jsx_element_childs(
+        &mut self,
+        node: Vec<JSXElementChild>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<JSXElementChild> {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_element_childs(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_element_childs(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
+    fn fold_jsx_element_name(
+        &mut self,
+        node: JSXElementName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXElementName {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_element_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_element_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
+    fn fold_jsx_empty_expr(
+        &mut self,
+        node: JSXEmptyExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXEmptyExpr {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_empty_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_empty_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_expr(&mut self, node: &JSXExpr) {
+    fn fold_jsx_expr(&mut self, node: JSXExpr, __ast_path: &mut AstKindPath) -> JSXExpr {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
+    fn fold_jsx_expr_container(
+        &mut self,
+        node: JSXExprContainer,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXExprContainer {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_expr_container(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_expr_container(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
+    fn fold_jsx_fragment(
+        &mut self,
+        node: JSXFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXFragment {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_fragment(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_fragment(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
+    fn fold_jsx_member_expr(
+        &mut self,
+        node: JSXMemberExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXMemberExpr {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_member_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_member_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
+    fn fold_jsx_namespaced_name(
+        &mut self,
+        node: JSXNamespacedName,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXNamespacedName {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_namespaced_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_namespaced_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_object(&mut self, node: &JSXObject) {
+    fn fold_jsx_object(&mut self, node: JSXObject, __ast_path: &mut AstKindPath) -> JSXObject {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_object(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_object(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
+    fn fold_jsx_opening_element(
+        &mut self,
+        node: JSXOpeningElement,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningElement {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_opening_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_opening_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
+    fn fold_jsx_opening_fragment(
+        &mut self,
+        node: JSXOpeningFragment,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXOpeningFragment {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_opening_fragment(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_opening_fragment(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
+    fn fold_jsx_spread_child(
+        &mut self,
+        node: JSXSpreadChild,
+        __ast_path: &mut AstKindPath,
+    ) -> JSXSpreadChild {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_spread_child(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_spread_child(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_jsx_text(&mut self, node: &JSXText) {
+    fn fold_jsx_text(&mut self, node: JSXText, __ast_path: &mut AstKindPath) -> JSXText {
         if self.enabled {
-            <V as VisitAll>::visit_jsx_text(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_jsx_text(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_key(&mut self, node: &Key) {
+    fn fold_key(&mut self, node: Key, __ast_path: &mut AstKindPath) -> Key {
         if self.enabled {
-            <V as VisitAll>::visit_key(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_key(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
+    fn fold_key_value_pat_prop(
+        &mut self,
+        node: KeyValuePatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValuePatProp {
         if self.enabled {
-            <V as VisitAll>::visit_key_value_pat_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_key_value_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
+    fn fold_key_value_prop(
+        &mut self,
+        node: KeyValueProp,
+        __ast_path: &mut AstKindPath,
+    ) -> KeyValueProp {
         if self.enabled {
-            <V as VisitAll>::visit_key_value_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_key_value_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
+    fn fold_labeled_stmt(
+        &mut self,
+        node: LabeledStmt,
+        __ast_path: &mut AstKindPath,
+    ) -> LabeledStmt {
         if self.enabled {
-            <V as VisitAll>::visit_labeled_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_labeled_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_lit(&mut self, node: &Lit) {
+    fn fold_lit(&mut self, node: Lit, __ast_path: &mut AstKindPath) -> Lit {
         if self.enabled {
-            <V as VisitAll>::visit_lit(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_lit(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_member_expr(&mut self, node: &MemberExpr) {
+    fn fold_member_expr(&mut self, node: MemberExpr, __ast_path: &mut AstKindPath) -> MemberExpr {
         if self.enabled {
-            <V as VisitAll>::visit_member_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_member_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_member_prop(&mut self, node: &MemberProp) {
+    fn fold_member_prop(&mut self, node: MemberProp, __ast_path: &mut AstKindPath) -> MemberProp {
         if self.enabled {
-            <V as VisitAll>::visit_member_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_member_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
+    fn fold_meta_prop_expr(
+        &mut self,
+        node: MetaPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropExpr {
         if self.enabled {
-            <V as VisitAll>::visit_meta_prop_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_meta_prop_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
+    fn fold_meta_prop_kind(
+        &mut self,
+        node: MetaPropKind,
+        __ast_path: &mut AstKindPath,
+    ) -> MetaPropKind {
         if self.enabled {
-            <V as VisitAll>::visit_meta_prop_kind(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_meta_prop_kind(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_method_kind(&mut self, node: &MethodKind) {
+    fn fold_method_kind(&mut self, node: MethodKind, __ast_path: &mut AstKindPath) -> MethodKind {
         if self.enabled {
-            <V as VisitAll>::visit_method_kind(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_method_kind(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_method_prop(&mut self, node: &MethodProp) {
+    fn fold_method_prop(&mut self, node: MethodProp, __ast_path: &mut AstKindPath) -> MethodProp {
         if self.enabled {
-            <V as VisitAll>::visit_method_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_method_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_module(&mut self, node: &Module) {
+    fn fold_module(&mut self, node: Module, __ast_path: &mut AstKindPath) -> Module {
         if self.enabled {
-            <V as VisitAll>::visit_module(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_module(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_module_decl(&mut self, node: &ModuleDecl) {
+    fn fold_module_decl(&mut self, node: ModuleDecl, __ast_path: &mut AstKindPath) -> ModuleDecl {
         if self.enabled {
-            <V as VisitAll>::visit_module_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_module_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_module_export_name(&mut self, node: &ModuleExportName) {
+    fn fold_module_export_name(
+        &mut self,
+        node: ModuleExportName,
+        __ast_path: &mut AstKindPath,
+    ) -> ModuleExportName {
         if self.enabled {
-            <V as VisitAll>::visit_module_export_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_module_export_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_module_item(&mut self, node: &ModuleItem) {
+    fn fold_module_item(&mut self, node: ModuleItem, __ast_path: &mut AstKindPath) -> ModuleItem {
         if self.enabled {
-            <V as VisitAll>::visit_module_item(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_module_item(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_module_items(&mut self, node: &[ModuleItem]) {
+    fn fold_module_items(
+        &mut self,
+        node: Vec<ModuleItem>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ModuleItem> {
         if self.enabled {
-            <V as VisitAll>::visit_module_items(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_module_items(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_named_export(&mut self, node: &NamedExport) {
+    fn fold_named_export(
+        &mut self,
+        node: NamedExport,
+        __ast_path: &mut AstKindPath,
+    ) -> NamedExport {
         if self.enabled {
-            <V as VisitAll>::visit_named_export(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_named_export(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_new_expr(&mut self, node: &NewExpr) {
+    fn fold_new_expr(&mut self, node: NewExpr, __ast_path: &mut AstKindPath) -> NewExpr {
         if self.enabled {
-            <V as VisitAll>::visit_new_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_new_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_null(&mut self, node: &Null) {
+    fn fold_null(&mut self, node: Null, __ast_path: &mut AstKindPath) -> Null {
         if self.enabled {
-            <V as VisitAll>::visit_null(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_null(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_number(&mut self, node: &Number) {
+    fn fold_number(&mut self, node: Number, __ast_path: &mut AstKindPath) -> Number {
         if self.enabled {
-            <V as VisitAll>::visit_number(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_number(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_object_lit(&mut self, node: &ObjectLit) {
+    fn fold_object_lit(&mut self, node: ObjectLit, __ast_path: &mut AstKindPath) -> ObjectLit {
         if self.enabled {
-            <V as VisitAll>::visit_object_lit(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_object_lit(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_object_pat(&mut self, node: &ObjectPat) {
+    fn fold_object_pat(&mut self, node: ObjectPat, __ast_path: &mut AstKindPath) -> ObjectPat {
         if self.enabled {
-            <V as VisitAll>::visit_object_pat(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_object_pat(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
+    fn fold_object_pat_prop(
+        &mut self,
+        node: ObjectPatProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ObjectPatProp {
         if self.enabled {
-            <V as VisitAll>::visit_object_pat_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_object_pat_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
+    fn fold_object_pat_props(
+        &mut self,
+        node: Vec<ObjectPatProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ObjectPatProp> {
         if self.enabled {
-            <V as VisitAll>::visit_object_pat_props(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_object_pat_props(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
+    fn fold_opt_accessibility(
+        &mut self,
+        node: Option<Accessibility>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Accessibility> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_accessibility(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_accessibility(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
+    fn fold_opt_atom(
+        &mut self,
+        node: Option<swc_atoms::Atom>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_atoms::Atom> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_atom(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_atom(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>) {
+    fn fold_opt_block_stmt(
+        &mut self,
+        node: Option<BlockStmt>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<BlockStmt> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_block_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_block_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_call(&mut self, node: &OptCall) {
+    fn fold_opt_call(&mut self, node: OptCall, __ast_path: &mut AstKindPath) -> OptCall {
         if self.enabled {
-            <V as VisitAll>::visit_opt_call(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_call(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>) {
+    fn fold_opt_catch_clause(
+        &mut self,
+        node: Option<CatchClause>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<CatchClause> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_catch_clause(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_catch_clause(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
+    fn fold_opt_chain_base(
+        &mut self,
+        node: OptChainBase,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainBase {
         if self.enabled {
-            <V as VisitAll>::visit_opt_chain_base(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_chain_base(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
+    fn fold_opt_chain_expr(
+        &mut self,
+        node: OptChainExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> OptChainExpr {
         if self.enabled {
-            <V as VisitAll>::visit_opt_chain_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_chain_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>) {
+    fn fold_opt_expr(
+        &mut self,
+        node: Option<Box<Expr>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Expr>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>) {
+    fn fold_opt_expr_or_spread(
+        &mut self,
+        node: Option<ExprOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ExprOrSpread> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_expr_or_spread(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_expr_or_spread(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>) {
+    fn fold_opt_expr_or_spreads(
+        &mut self,
+        node: Option<Vec<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Vec<ExprOrSpread>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_expr_or_spreads(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_expr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ident(&mut self, node: &Option<Ident>) {
+    fn fold_opt_ident(
+        &mut self,
+        node: Option<Ident>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Ident> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>) {
+    fn fold_opt_jsx_attr_value(
+        &mut self,
+        node: Option<JSXAttrValue>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXAttrValue> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_jsx_attr_value(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_jsx_attr_value(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>) {
+    fn fold_opt_jsx_closing_element(
+        &mut self,
+        node: Option<JSXClosingElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<JSXClosingElement> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_jsx_closing_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_jsx_closing_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_module_export_name(&mut self, node: &Option<ModuleExportName>) {
+    fn fold_opt_module_export_name(
+        &mut self,
+        node: Option<ModuleExportName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<ModuleExportName> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_module_export_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_module_export_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_object_lit(&mut self, node: &Option<Box<ObjectLit>>) {
+    fn fold_opt_object_lit(
+        &mut self,
+        node: Option<Box<ObjectLit>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<ObjectLit>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_object_lit(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_object_lit(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_pat(&mut self, node: &Option<Pat>) {
+    fn fold_opt_pat(&mut self, node: Option<Pat>, __ast_path: &mut AstKindPath) -> Option<Pat> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_pat(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_pat(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_span(&mut self, node: &Option<swc_common::Span>) {
+    fn fold_opt_span(
+        &mut self,
+        node: Option<swc_common::Span>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<swc_common::Span> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_span(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_span(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>) {
+    fn fold_opt_stmt(
+        &mut self,
+        node: Option<Box<Stmt>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Stmt>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_str(&mut self, node: &Option<Box<Str>>) {
+    fn fold_opt_str(
+        &mut self,
+        node: Option<Box<Str>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<Str>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_str(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_str(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>) {
+    fn fold_opt_true_plus_minus(
+        &mut self,
+        node: Option<TruePlusMinus>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TruePlusMinus> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_true_plus_minus(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_true_plus_minus(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>) {
+    fn fold_opt_ts_entity_name(
+        &mut self,
+        node: Option<TsEntityName>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsEntityName> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ts_entity_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ts_entity_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>) {
+    fn fold_opt_ts_namespace_body(
+        &mut self,
+        node: Option<TsNamespaceBody>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<TsNamespaceBody> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ts_namespace_body(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ts_namespace_body(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>) {
+    fn fold_opt_ts_type(
+        &mut self,
+        node: Option<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsType>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ts_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ts_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>) {
+    fn fold_opt_ts_type_ann(
+        &mut self,
+        node: Option<Box<TsTypeAnn>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeAnn>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ts_type_ann(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ts_type_ann(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_decl(&mut self, node: &Option<Box<TsTypeParamDecl>>) {
+    fn fold_opt_ts_type_param_decl(
+        &mut self,
+        node: Option<Box<TsTypeParamDecl>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamDecl>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ts_type_param_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ts_type_param_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_ts_type_param_instantiation(
+    fn fold_opt_ts_type_param_instantiation(
         &mut self,
-        node: &Option<Box<TsTypeParamInstantiation>>,
-    ) {
+        node: Option<Box<TsTypeParamInstantiation>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<Box<TsTypeParamInstantiation>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_ts_type_param_instantiation(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>) {
+    fn fold_opt_var_decl_or_expr(
+        &mut self,
+        node: Option<VarDeclOrExpr>,
+        __ast_path: &mut AstKindPath,
+    ) -> Option<VarDeclOrExpr> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_var_decl_or_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_var_decl_or_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>]) {
+    fn fold_opt_vec_expr_or_spreads(
+        &mut self,
+        node: Vec<Option<ExprOrSpread>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<ExprOrSpread>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_vec_expr_or_spreads(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>]) {
+    fn fold_opt_vec_pats(
+        &mut self,
+        node: Vec<Option<Pat>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Option<Pat>> {
         if self.enabled {
-            <V as VisitAll>::visit_opt_vec_pats(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_opt_vec_pats(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_param(&mut self, node: &Param) {
+    fn fold_param(&mut self, node: Param, __ast_path: &mut AstKindPath) -> Param {
         if self.enabled {
-            <V as VisitAll>::visit_param(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_param(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp) {
+    fn fold_param_or_ts_param_prop(
+        &mut self,
+        node: ParamOrTsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> ParamOrTsParamProp {
         if self.enabled {
-            <V as VisitAll>::visit_param_or_ts_param_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_param_or_ts_param_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp]) {
+    fn fold_param_or_ts_param_props(
+        &mut self,
+        node: Vec<ParamOrTsParamProp>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<ParamOrTsParamProp> {
         if self.enabled {
-            <V as VisitAll>::visit_param_or_ts_param_props(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_param_or_ts_param_props(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_params(&mut self, node: &[Param]) {
+    fn fold_params(&mut self, node: Vec<Param>, __ast_path: &mut AstKindPath) -> Vec<Param> {
         if self.enabled {
-            <V as VisitAll>::visit_params(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_params(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_paren_expr(&mut self, node: &ParenExpr) {
+    fn fold_paren_expr(&mut self, node: ParenExpr, __ast_path: &mut AstKindPath) -> ParenExpr {
         if self.enabled {
-            <V as VisitAll>::visit_paren_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_paren_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pat(&mut self, node: &Pat) {
+    fn fold_pat(&mut self, node: Pat, __ast_path: &mut AstKindPath) -> Pat {
         if self.enabled {
-            <V as VisitAll>::visit_pat(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pat(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_pats(&mut self, node: &[Pat]) {
+    fn fold_pats(&mut self, node: Vec<Pat>, __ast_path: &mut AstKindPath) -> Vec<Pat> {
         if self.enabled {
-            <V as VisitAll>::visit_pats(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_pats(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_private_method(&mut self, node: &PrivateMethod) {
+    fn fold_private_method(
+        &mut self,
+        node: PrivateMethod,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateMethod {
         if self.enabled {
-            <V as VisitAll>::visit_private_method(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_private_method(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_private_name(&mut self, node: &PrivateName) {
+    fn fold_private_name(
+        &mut self,
+        node: PrivateName,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateName {
         if self.enabled {
-            <V as VisitAll>::visit_private_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_private_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_private_prop(&mut self, node: &PrivateProp) {
+    fn fold_private_prop(
+        &mut self,
+        node: PrivateProp,
+        __ast_path: &mut AstKindPath,
+    ) -> PrivateProp {
         if self.enabled {
-            <V as VisitAll>::visit_private_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_private_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_program(&mut self, node: &Program) {
+    fn fold_program(&mut self, node: Program, __ast_path: &mut AstKindPath) -> Program {
         if self.enabled {
-            <V as VisitAll>::visit_program(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_program(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_prop(&mut self, node: &Prop) {
+    fn fold_prop(&mut self, node: Prop, __ast_path: &mut AstKindPath) -> Prop {
         if self.enabled {
-            <V as VisitAll>::visit_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_prop_name(&mut self, node: &PropName) {
+    fn fold_prop_name(&mut self, node: PropName, __ast_path: &mut AstKindPath) -> PropName {
         if self.enabled {
-            <V as VisitAll>::visit_prop_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_prop_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
+    fn fold_prop_or_spread(
+        &mut self,
+        node: PropOrSpread,
+        __ast_path: &mut AstKindPath,
+    ) -> PropOrSpread {
         if self.enabled {
-            <V as VisitAll>::visit_prop_or_spread(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_prop_or_spread(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
+    fn fold_prop_or_spreads(
+        &mut self,
+        node: Vec<PropOrSpread>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<PropOrSpread> {
         if self.enabled {
-            <V as VisitAll>::visit_prop_or_spreads(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_prop_or_spreads(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_regex(&mut self, node: &Regex) {
+    fn fold_regex(&mut self, node: Regex, __ast_path: &mut AstKindPath) -> Regex {
         if self.enabled {
-            <V as VisitAll>::visit_regex(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_regex(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_rest_pat(&mut self, node: &RestPat) {
+    fn fold_rest_pat(&mut self, node: RestPat, __ast_path: &mut AstKindPath) -> RestPat {
         if self.enabled {
-            <V as VisitAll>::visit_rest_pat(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_rest_pat(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_return_stmt(&mut self, node: &ReturnStmt) {
+    fn fold_return_stmt(&mut self, node: ReturnStmt, __ast_path: &mut AstKindPath) -> ReturnStmt {
         if self.enabled {
-            <V as VisitAll>::visit_return_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_return_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_script(&mut self, node: &Script) {
+    fn fold_script(&mut self, node: Script, __ast_path: &mut AstKindPath) -> Script {
         if self.enabled {
-            <V as VisitAll>::visit_script(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_script(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_seq_expr(&mut self, node: &SeqExpr) {
+    fn fold_seq_expr(&mut self, node: SeqExpr, __ast_path: &mut AstKindPath) -> SeqExpr {
         if self.enabled {
-            <V as VisitAll>::visit_seq_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_seq_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_setter_prop(&mut self, node: &SetterProp) {
+    fn fold_setter_prop(&mut self, node: SetterProp, __ast_path: &mut AstKindPath) -> SetterProp {
         if self.enabled {
-            <V as VisitAll>::visit_setter_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_setter_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
+    fn fold_simple_assign_target(
+        &mut self,
+        node: SimpleAssignTarget,
+        __ast_path: &mut AstKindPath,
+    ) -> SimpleAssignTarget {
         if self.enabled {
-            <V as VisitAll>::visit_simple_assign_target(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_simple_assign_target(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
+    fn fold_span(
+        &mut self,
+        node: swc_common::Span,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::Span {
         if self.enabled {
-            <V as VisitAll>::visit_span(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_span(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_spread_element(&mut self, node: &SpreadElement) {
+    fn fold_spread_element(
+        &mut self,
+        node: SpreadElement,
+        __ast_path: &mut AstKindPath,
+    ) -> SpreadElement {
         if self.enabled {
-            <V as VisitAll>::visit_spread_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_spread_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_static_block(&mut self, node: &StaticBlock) {
+    fn fold_static_block(
+        &mut self,
+        node: StaticBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> StaticBlock {
         if self.enabled {
-            <V as VisitAll>::visit_static_block(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_static_block(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_stmt(&mut self, node: &Stmt) {
+    fn fold_stmt(&mut self, node: Stmt, __ast_path: &mut AstKindPath) -> Stmt {
         if self.enabled {
-            <V as VisitAll>::visit_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_stmts(&mut self, node: &[Stmt]) {
+    fn fold_stmts(&mut self, node: Vec<Stmt>, __ast_path: &mut AstKindPath) -> Vec<Stmt> {
         if self.enabled {
-            <V as VisitAll>::visit_stmts(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_stmts(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_str(&mut self, node: &Str) {
+    fn fold_str(&mut self, node: Str, __ast_path: &mut AstKindPath) -> Str {
         if self.enabled {
-            <V as VisitAll>::visit_str(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_str(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_super(&mut self, node: &Super) {
+    fn fold_super(&mut self, node: Super, __ast_path: &mut AstKindPath) -> Super {
         if self.enabled {
-            <V as VisitAll>::visit_super(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_super(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_super_prop(&mut self, node: &SuperProp) {
+    fn fold_super_prop(&mut self, node: SuperProp, __ast_path: &mut AstKindPath) -> SuperProp {
         if self.enabled {
-            <V as VisitAll>::visit_super_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_super_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
+    fn fold_super_prop_expr(
+        &mut self,
+        node: SuperPropExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> SuperPropExpr {
         if self.enabled {
-            <V as VisitAll>::visit_super_prop_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_super_prop_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_switch_case(&mut self, node: &SwitchCase) {
+    fn fold_switch_case(&mut self, node: SwitchCase, __ast_path: &mut AstKindPath) -> SwitchCase {
         if self.enabled {
-            <V as VisitAll>::visit_switch_case(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_switch_case(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
+    fn fold_switch_cases(
+        &mut self,
+        node: Vec<SwitchCase>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<SwitchCase> {
         if self.enabled {
-            <V as VisitAll>::visit_switch_cases(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_switch_cases(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
+    fn fold_switch_stmt(&mut self, node: SwitchStmt, __ast_path: &mut AstKindPath) -> SwitchStmt {
         if self.enabled {
-            <V as VisitAll>::visit_switch_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_switch_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_syntax_context(&mut self, node: &swc_common::SyntaxContext) {
+    fn fold_syntax_context(
+        &mut self,
+        node: swc_common::SyntaxContext,
+        __ast_path: &mut AstKindPath,
+    ) -> swc_common::SyntaxContext {
         if self.enabled {
-            <V as VisitAll>::visit_syntax_context(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_syntax_context(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
+    fn fold_tagged_tpl(&mut self, node: TaggedTpl, __ast_path: &mut AstKindPath) -> TaggedTpl {
         if self.enabled {
-            <V as VisitAll>::visit_tagged_tpl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_tagged_tpl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_this_expr(&mut self, node: &ThisExpr) {
+    fn fold_this_expr(&mut self, node: ThisExpr, __ast_path: &mut AstKindPath) -> ThisExpr {
         if self.enabled {
-            <V as VisitAll>::visit_this_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_this_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
+    fn fold_throw_stmt(&mut self, node: ThrowStmt, __ast_path: &mut AstKindPath) -> ThrowStmt {
         if self.enabled {
-            <V as VisitAll>::visit_throw_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_throw_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_tpl(&mut self, node: &Tpl) {
+    fn fold_tpl(&mut self, node: Tpl, __ast_path: &mut AstKindPath) -> Tpl {
         if self.enabled {
-            <V as VisitAll>::visit_tpl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_tpl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_tpl_element(&mut self, node: &TplElement) {
+    fn fold_tpl_element(&mut self, node: TplElement, __ast_path: &mut AstKindPath) -> TplElement {
         if self.enabled {
-            <V as VisitAll>::visit_tpl_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_tpl_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_tpl_elements(&mut self, node: &[TplElement]) {
+    fn fold_tpl_elements(
+        &mut self,
+        node: Vec<TplElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TplElement> {
         if self.enabled {
-            <V as VisitAll>::visit_tpl_elements(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_tpl_elements(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
+    fn fold_true_plus_minus(
+        &mut self,
+        node: TruePlusMinus,
+        __ast_path: &mut AstKindPath,
+    ) -> TruePlusMinus {
         if self.enabled {
-            <V as VisitAll>::visit_true_plus_minus(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_true_plus_minus(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_try_stmt(&mut self, node: &TryStmt) {
+    fn fold_try_stmt(&mut self, node: TryStmt, __ast_path: &mut AstKindPath) -> TryStmt {
         if self.enabled {
-            <V as VisitAll>::visit_try_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_try_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_array_type(&mut self, node: &TsArrayType) {
+    fn fold_ts_array_type(
+        &mut self,
+        node: TsArrayType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsArrayType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_array_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_array_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
+    fn fold_ts_as_expr(&mut self, node: TsAsExpr, __ast_path: &mut AstKindPath) -> TsAsExpr {
         if self.enabled {
-            <V as VisitAll>::visit_ts_as_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_as_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
+    fn fold_ts_call_signature_decl(
+        &mut self,
+        node: TsCallSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsCallSignatureDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_call_signature_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_call_signature_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
+    fn fold_ts_conditional_type(
+        &mut self,
+        node: TsConditionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConditionalType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_conditional_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_conditional_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
+    fn fold_ts_const_assertion(
+        &mut self,
+        node: TsConstAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstAssertion {
         if self.enabled {
-            <V as VisitAll>::visit_ts_const_assertion(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_const_assertion(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
+    fn fold_ts_construct_signature_decl(
+        &mut self,
+        node: TsConstructSignatureDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructSignatureDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_construct_signature_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_construct_signature_decl(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
+    fn fold_ts_constructor_type(
+        &mut self,
+        node: TsConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsConstructorType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_constructor_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_constructor_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
+    fn fold_ts_entity_name(
+        &mut self,
+        node: TsEntityName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEntityName {
         if self.enabled {
-            <V as VisitAll>::visit_ts_entity_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_entity_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
+    fn fold_ts_enum_decl(&mut self, node: TsEnumDecl, __ast_path: &mut AstKindPath) -> TsEnumDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_enum_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_enum_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
+    fn fold_ts_enum_member(
+        &mut self,
+        node: TsEnumMember,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMember {
         if self.enabled {
-            <V as VisitAll>::visit_ts_enum_member(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_enum_member(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
+    fn fold_ts_enum_member_id(
+        &mut self,
+        node: TsEnumMemberId,
+        __ast_path: &mut AstKindPath,
+    ) -> TsEnumMemberId {
         if self.enabled {
-            <V as VisitAll>::visit_ts_enum_member_id(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_enum_member_id(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
+    fn fold_ts_enum_members(
+        &mut self,
+        node: Vec<TsEnumMember>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsEnumMember> {
         if self.enabled {
-            <V as VisitAll>::visit_ts_enum_members(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_enum_members(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
+    fn fold_ts_export_assignment(
+        &mut self,
+        node: TsExportAssignment,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExportAssignment {
         if self.enabled {
-            <V as VisitAll>::visit_ts_export_assignment(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_export_assignment(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs) {
+    fn fold_ts_expr_with_type_args(
+        &mut self,
+        node: TsExprWithTypeArgs,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExprWithTypeArgs {
         if self.enabled {
-            <V as VisitAll>::visit_ts_expr_with_type_args(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_expr_with_type_args(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs]) {
+    fn fold_ts_expr_with_type_argss(
+        &mut self,
+        node: Vec<TsExprWithTypeArgs>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsExprWithTypeArgs> {
         if self.enabled {
-            <V as VisitAll>::visit_ts_expr_with_type_argss(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_expr_with_type_argss(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
+    fn fold_ts_external_module_ref(
+        &mut self,
+        node: TsExternalModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsExternalModuleRef {
         if self.enabled {
-            <V as VisitAll>::visit_ts_external_module_ref(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_external_module_ref(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType) {
+    fn fold_ts_fn_or_constructor_type(
+        &mut self,
+        node: TsFnOrConstructorType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsFnOrConstructorType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_fn_or_constructor_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_fn_or_constructor_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
+    fn fold_ts_fn_param(&mut self, node: TsFnParam, __ast_path: &mut AstKindPath) -> TsFnParam {
         if self.enabled {
-            <V as VisitAll>::visit_ts_fn_param(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_fn_param(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
+    fn fold_ts_fn_params(
+        &mut self,
+        node: Vec<TsFnParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsFnParam> {
         if self.enabled {
-            <V as VisitAll>::visit_ts_fn_params(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_fn_params(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_fn_type(&mut self, node: &TsFnType) {
+    fn fold_ts_fn_type(&mut self, node: TsFnType, __ast_path: &mut AstKindPath) -> TsFnType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_fn_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_fn_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
+    fn fold_ts_getter_signature(
+        &mut self,
+        node: TsGetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsGetterSignature {
         if self.enabled {
-            <V as VisitAll>::visit_ts_getter_signature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_getter_signature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
+    fn fold_ts_import_equals_decl(
+        &mut self,
+        node: TsImportEqualsDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportEqualsDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_import_equals_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_import_equals_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_import_type(&mut self, node: &TsImportType) {
+    fn fold_ts_import_type(
+        &mut self,
+        node: TsImportType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsImportType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_import_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_import_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
+    fn fold_ts_index_signature(
+        &mut self,
+        node: TsIndexSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexSignature {
         if self.enabled {
-            <V as VisitAll>::visit_ts_index_signature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_index_signature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
+    fn fold_ts_indexed_access_type(
+        &mut self,
+        node: TsIndexedAccessType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIndexedAccessType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_indexed_access_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_indexed_access_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_infer_type(&mut self, node: &TsInferType) {
+    fn fold_ts_infer_type(
+        &mut self,
+        node: TsInferType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInferType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_infer_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_infer_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
+    fn fold_ts_instantiation(
+        &mut self,
+        node: TsInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInstantiation {
         if self.enabled {
-            <V as VisitAll>::visit_ts_instantiation(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_instantiation(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
+    fn fold_ts_interface_body(
+        &mut self,
+        node: TsInterfaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceBody {
         if self.enabled {
-            <V as VisitAll>::visit_ts_interface_body(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_interface_body(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
+    fn fold_ts_interface_decl(
+        &mut self,
+        node: TsInterfaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsInterfaceDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_interface_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_interface_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
+    fn fold_ts_intersection_type(
+        &mut self,
+        node: TsIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsIntersectionType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_intersection_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_intersection_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
+    fn fold_ts_keyword_type(
+        &mut self,
+        node: TsKeywordType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_keyword_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_keyword_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
+    fn fold_ts_keyword_type_kind(
+        &mut self,
+        node: TsKeywordTypeKind,
+        __ast_path: &mut AstKindPath,
+    ) -> TsKeywordTypeKind {
         if self.enabled {
-            <V as VisitAll>::visit_ts_keyword_type_kind(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_keyword_type_kind(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_lit(&mut self, node: &TsLit) {
+    fn fold_ts_lit(&mut self, node: TsLit, __ast_path: &mut AstKindPath) -> TsLit {
         if self.enabled {
-            <V as VisitAll>::visit_ts_lit(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_lit(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_lit_type(&mut self, node: &TsLitType) {
+    fn fold_ts_lit_type(&mut self, node: TsLitType, __ast_path: &mut AstKindPath) -> TsLitType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_lit_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_lit_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
+    fn fold_ts_mapped_type(
+        &mut self,
+        node: TsMappedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMappedType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_mapped_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_mapped_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
+    fn fold_ts_method_signature(
+        &mut self,
+        node: TsMethodSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsMethodSignature {
         if self.enabled {
-            <V as VisitAll>::visit_ts_method_signature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_method_signature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
+    fn fold_ts_module_block(
+        &mut self,
+        node: TsModuleBlock,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleBlock {
         if self.enabled {
-            <V as VisitAll>::visit_ts_module_block(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_module_block(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
+    fn fold_ts_module_decl(
+        &mut self,
+        node: TsModuleDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_module_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_module_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_module_name(&mut self, node: &TsModuleName) {
+    fn fold_ts_module_name(
+        &mut self,
+        node: TsModuleName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleName {
         if self.enabled {
-            <V as VisitAll>::visit_ts_module_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_module_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
+    fn fold_ts_module_ref(
+        &mut self,
+        node: TsModuleRef,
+        __ast_path: &mut AstKindPath,
+    ) -> TsModuleRef {
         if self.enabled {
-            <V as VisitAll>::visit_ts_module_ref(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_module_ref(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
+    fn fold_ts_namespace_body(
+        &mut self,
+        node: TsNamespaceBody,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceBody {
         if self.enabled {
-            <V as VisitAll>::visit_ts_namespace_body(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_namespace_body(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
+    fn fold_ts_namespace_decl(
+        &mut self,
+        node: TsNamespaceDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_namespace_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_namespace_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
+    fn fold_ts_namespace_export_decl(
+        &mut self,
+        node: TsNamespaceExportDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNamespaceExportDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_namespace_export_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_namespace_export_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
+    fn fold_ts_non_null_expr(
+        &mut self,
+        node: TsNonNullExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsNonNullExpr {
         if self.enabled {
-            <V as VisitAll>::visit_ts_non_null_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_non_null_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
+    fn fold_ts_optional_type(
+        &mut self,
+        node: TsOptionalType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsOptionalType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_optional_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_optional_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
+    fn fold_ts_param_prop(
+        &mut self,
+        node: TsParamProp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamProp {
         if self.enabled {
-            <V as VisitAll>::visit_ts_param_prop(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_param_prop(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
+    fn fold_ts_param_prop_param(
+        &mut self,
+        node: TsParamPropParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParamPropParam {
         if self.enabled {
-            <V as VisitAll>::visit_ts_param_prop_param(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_param_prop_param(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
+    fn fold_ts_parenthesized_type(
+        &mut self,
+        node: TsParenthesizedType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsParenthesizedType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_parenthesized_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_parenthesized_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
+    fn fold_ts_property_signature(
+        &mut self,
+        node: TsPropertySignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsPropertySignature {
         if self.enabled {
-            <V as VisitAll>::visit_ts_property_signature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_property_signature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
+    fn fold_ts_qualified_name(
+        &mut self,
+        node: TsQualifiedName,
+        __ast_path: &mut AstKindPath,
+    ) -> TsQualifiedName {
         if self.enabled {
-            <V as VisitAll>::visit_ts_qualified_name(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_qualified_name(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_rest_type(&mut self, node: &TsRestType) {
+    fn fold_ts_rest_type(&mut self, node: TsRestType, __ast_path: &mut AstKindPath) -> TsRestType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_rest_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_rest_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
+    fn fold_ts_satisfies_expr(
+        &mut self,
+        node: TsSatisfiesExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSatisfiesExpr {
         if self.enabled {
-            <V as VisitAll>::visit_ts_satisfies_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_satisfies_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
+    fn fold_ts_setter_signature(
+        &mut self,
+        node: TsSetterSignature,
+        __ast_path: &mut AstKindPath,
+    ) -> TsSetterSignature {
         if self.enabled {
-            <V as VisitAll>::visit_ts_setter_signature(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_setter_signature(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_this_type(&mut self, node: &TsThisType) {
+    fn fold_ts_this_type(&mut self, node: TsThisType, __ast_path: &mut AstKindPath) -> TsThisType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_this_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_this_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent) {
+    fn fold_ts_this_type_or_ident(
+        &mut self,
+        node: TsThisTypeOrIdent,
+        __ast_path: &mut AstKindPath,
+    ) -> TsThisTypeOrIdent {
         if self.enabled {
-            <V as VisitAll>::visit_ts_this_type_or_ident(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_this_type_or_ident(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
+    fn fold_ts_tpl_lit_type(
+        &mut self,
+        node: TsTplLitType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTplLitType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_tpl_lit_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_tpl_lit_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
+    fn fold_ts_tuple_element(
+        &mut self,
+        node: TsTupleElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleElement {
         if self.enabled {
-            <V as VisitAll>::visit_ts_tuple_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_tuple_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
+    fn fold_ts_tuple_elements(
+        &mut self,
+        node: Vec<TsTupleElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTupleElement> {
         if self.enabled {
-            <V as VisitAll>::visit_ts_tuple_elements(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_tuple_elements(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
+    fn fold_ts_tuple_type(
+        &mut self,
+        node: TsTupleType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTupleType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_tuple_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_tuple_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type(&mut self, node: &TsType) {
+    fn fold_ts_type(&mut self, node: TsType, __ast_path: &mut AstKindPath) -> TsType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
+    fn fold_ts_type_alias_decl(
+        &mut self,
+        node: TsTypeAliasDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAliasDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_alias_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_alias_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
+    fn fold_ts_type_ann(&mut self, node: TsTypeAnn, __ast_path: &mut AstKindPath) -> TsTypeAnn {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_ann(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_ann(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
+    fn fold_ts_type_assertion(
+        &mut self,
+        node: TsTypeAssertion,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeAssertion {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_assertion(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_assertion(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
+    fn fold_ts_type_element(
+        &mut self,
+        node: TsTypeElement,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeElement {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_element(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_element(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
+    fn fold_ts_type_elements(
+        &mut self,
+        node: Vec<TsTypeElement>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeElement> {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_elements(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_elements(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
+    fn fold_ts_type_lit(&mut self, node: TsTypeLit, __ast_path: &mut AstKindPath) -> TsTypeLit {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_lit(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_lit(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
+    fn fold_ts_type_operator(
+        &mut self,
+        node: TsTypeOperator,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperator {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_operator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_operator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
+    fn fold_ts_type_operator_op(
+        &mut self,
+        node: TsTypeOperatorOp,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeOperatorOp {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_operator_op(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_operator_op(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
+    fn fold_ts_type_param(
+        &mut self,
+        node: TsTypeParam,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParam {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_param(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_param(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
+    fn fold_ts_type_param_decl(
+        &mut self,
+        node: TsTypeParamDecl,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamDecl {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_param_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_param_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
+    fn fold_ts_type_param_instantiation(
+        &mut self,
+        node: TsTypeParamInstantiation,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeParamInstantiation {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_param_instantiation(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_param_instantiation(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
+    fn fold_ts_type_params(
+        &mut self,
+        node: Vec<TsTypeParam>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<TsTypeParam> {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_params(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_params(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
+    fn fold_ts_type_predicate(
+        &mut self,
+        node: TsTypePredicate,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypePredicate {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_predicate(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_predicate(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
+    fn fold_ts_type_query(
+        &mut self,
+        node: TsTypeQuery,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQuery {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_query(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_query(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
+    fn fold_ts_type_query_expr(
+        &mut self,
+        node: TsTypeQueryExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> TsTypeQueryExpr {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_query_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_query_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
+    fn fold_ts_type_ref(&mut self, node: TsTypeRef, __ast_path: &mut AstKindPath) -> TsTypeRef {
         if self.enabled {
-            <V as VisitAll>::visit_ts_type_ref(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_type_ref(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
+    fn fold_ts_types(
+        &mut self,
+        node: Vec<Box<TsType>>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<Box<TsType>> {
         if self.enabled {
-            <V as VisitAll>::visit_ts_types(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_types(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_union_or_intersection_type(&mut self, node: &TsUnionOrIntersectionType) {
+    fn fold_ts_union_or_intersection_type(
+        &mut self,
+        node: TsUnionOrIntersectionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionOrIntersectionType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_union_or_intersection_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_union_or_intersection_type(
+                &mut self.visitor,
+                node,
+                __ast_path,
+            )
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_ts_union_type(&mut self, node: &TsUnionType) {
+    fn fold_ts_union_type(
+        &mut self,
+        node: TsUnionType,
+        __ast_path: &mut AstKindPath,
+    ) -> TsUnionType {
         if self.enabled {
-            <V as VisitAll>::visit_ts_union_type(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_ts_union_type(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_unary_expr(&mut self, node: &UnaryExpr) {
+    fn fold_unary_expr(&mut self, node: UnaryExpr, __ast_path: &mut AstKindPath) -> UnaryExpr {
         if self.enabled {
-            <V as VisitAll>::visit_unary_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_unary_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_unary_op(&mut self, node: &UnaryOp) {
+    fn fold_unary_op(&mut self, node: UnaryOp, __ast_path: &mut AstKindPath) -> UnaryOp {
         if self.enabled {
-            <V as VisitAll>::visit_unary_op(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_unary_op(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_update_expr(&mut self, node: &UpdateExpr) {
+    fn fold_update_expr(&mut self, node: UpdateExpr, __ast_path: &mut AstKindPath) -> UpdateExpr {
         if self.enabled {
-            <V as VisitAll>::visit_update_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_update_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_update_op(&mut self, node: &UpdateOp) {
+    fn fold_update_op(&mut self, node: UpdateOp, __ast_path: &mut AstKindPath) -> UpdateOp {
         if self.enabled {
-            <V as VisitAll>::visit_update_op(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_update_op(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_using_decl(&mut self, node: &UsingDecl) {
+    fn fold_using_decl(&mut self, node: UsingDecl, __ast_path: &mut AstKindPath) -> UsingDecl {
         if self.enabled {
-            <V as VisitAll>::visit_using_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_using_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_var_decl(&mut self, node: &VarDecl) {
+    fn fold_var_decl(&mut self, node: VarDecl, __ast_path: &mut AstKindPath) -> VarDecl {
         if self.enabled {
-            <V as VisitAll>::visit_var_decl(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_var_decl(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
+    fn fold_var_decl_kind(
+        &mut self,
+        node: VarDeclKind,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclKind {
         if self.enabled {
-            <V as VisitAll>::visit_var_decl_kind(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_var_decl_kind(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
+    fn fold_var_decl_or_expr(
+        &mut self,
+        node: VarDeclOrExpr,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclOrExpr {
         if self.enabled {
-            <V as VisitAll>::visit_var_decl_or_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_var_decl_or_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_var_declarator(&mut self, node: &VarDeclarator) {
+    fn fold_var_declarator(
+        &mut self,
+        node: VarDeclarator,
+        __ast_path: &mut AstKindPath,
+    ) -> VarDeclarator {
         if self.enabled {
-            <V as VisitAll>::visit_var_declarator(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_var_declarator(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
+    fn fold_var_declarators(
+        &mut self,
+        node: Vec<VarDeclarator>,
+        __ast_path: &mut AstKindPath,
+    ) -> Vec<VarDeclarator> {
         if self.enabled {
-            <V as VisitAll>::visit_var_declarators(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_var_declarators(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_while_stmt(&mut self, node: &WhileStmt) {
+    fn fold_while_stmt(&mut self, node: WhileStmt, __ast_path: &mut AstKindPath) -> WhileStmt {
         if self.enabled {
-            <V as VisitAll>::visit_while_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_while_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_with_stmt(&mut self, node: &WithStmt) {
+    fn fold_with_stmt(&mut self, node: WithStmt, __ast_path: &mut AstKindPath) -> WithStmt {
         if self.enabled {
-            <V as VisitAll>::visit_with_stmt(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_with_stmt(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 
     #[inline]
-    fn visit_yield_expr(&mut self, node: &YieldExpr) {
+    fn fold_yield_expr(&mut self, node: YieldExpr, __ast_path: &mut AstKindPath) -> YieldExpr {
         if self.enabled {
-            <V as VisitAll>::visit_yield_expr(&mut self.visitor, node)
+            <V as FoldAstPath>::fold_yield_expr(&mut self.visitor, node, __ast_path)
         } else {
+            node
         }
     }
 }
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitAllWith<V: ?Sized + VisitAll> {
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+pub trait FoldWithAstPath<V: ?Sized + FoldAstPath> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with(&self, visitor: &mut V);
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
     #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with(&self, visitor: &mut V);
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self;
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Accessibility {
-    #[doc = "Calls [VisitAll`::visit_accessibility`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_accessibility(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Accessibility {
+    #[doc = "Calls [FoldAstPath`::fold_accessibility`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_accessibility(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            Accessibility::Public => {}
-            Accessibility::Protected => {}
-            Accessibility::Private => {}
+            Accessibility::Public => Accessibility::Public,
+            Accessibility::Protected => Accessibility::Protected,
+            Accessibility::Private => Accessibility::Private,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ArrayLit {
-    #[doc = "Calls [VisitAll`::visit_array_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_array_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrayLit {
+    #[doc = "Calls [FoldAstPath`::fold_array_lit`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_array_lit(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ArrayLit { span, elems } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrayLit(self::fields::ArrayLitField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Option<ExprOrSpread>> as VisitAllWith<V>>::visit_with(elems, visitor)
+                let elems = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayLit(
+                        self::fields::ArrayLitField::Elems(usize::MAX),
+                    ));
+                    <Vec<Option<ExprOrSpread>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        elems,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ArrayLit { span, elems }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ArrayPat {
-    #[doc = "Calls [VisitAll`::visit_array_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_array_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrayPat {
+    #[doc = "Calls [FoldAstPath`::fold_array_pat`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_array_pat(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ArrayPat {
                 span,
@@ -147644,26 +122955,54 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ArrayPat {
                 optional,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrayPat(self::fields::ArrayPatField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Option<Pat>> as VisitAllWith<V>>::visit_with(elems, visitor)
+                let elems = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
+                        self::fields::ArrayPatField::Elems(usize::MAX),
+                    ));
+                    <Vec<Option<Pat>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        elems,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrayPat(
+                        self::fields::ArrayPatField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ArrayPat {
+                    span,
+                    elems,
+                    optional,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ArrowExpr {
-    #[doc = "Calls [VisitAll`::visit_arrow_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_arrow_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ArrowExpr {
+    #[doc = "Calls [FoldAstPath`::fold_arrow_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_arrow_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ArrowExpr {
                 span,
@@ -147675,38 +123014,86 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ArrowExpr {
                 type_params,
                 return_type,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Pat> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
+                        self::fields::ArrowExprField::Params(usize::MAX),
+                    ));
+                    <Vec<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<BlockStmtOrExpr> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ArrowExpr(self::fields::ArrowExprField::Body));
+                    <Box<BlockStmtOrExpr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
+                        self::fields::ArrowExprField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(return_type, visitor)
+                let return_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ArrowExpr(
+                        self::fields::ArrowExprField::ReturnType,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        return_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ArrowExpr {
+                    span,
+                    ctxt,
+                    params,
+                    body,
+                    is_async,
+                    is_generator,
+                    type_params,
+                    return_type,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignExpr {
-    #[doc = "Calls [VisitAll`::visit_assign_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_assign_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignExpr {
+    #[doc = "Calls [FoldAstPath`::fold_assign_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_assign_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AssignExpr {
                 span,
@@ -147714,159 +123101,310 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignExpr {
                 left,
                 right,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
+                        self::fields::AssignExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <AssignOp as VisitAllWith<V>>::visit_with(op, visitor)
+                let op = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AssignExpr(self::fields::AssignExprField::Op));
+                    <AssignOp as FoldWithAstPath<V>>::fold_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <AssignTarget as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
+                        self::fields::AssignExprField::Left,
+                    ));
+                    <AssignTarget as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignExpr(
+                        self::fields::AssignExprField::Right,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AssignExpr {
+                    span,
+                    op,
+                    left,
+                    right,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignOp {
-    #[doc = "Calls [VisitAll`::visit_assign_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_assign_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignOp {
+    #[doc = "Calls [FoldAstPath`::fold_assign_op`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_assign_op(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            AssignOp::Assign => {}
-            AssignOp::AddAssign => {}
-            AssignOp::SubAssign => {}
-            AssignOp::MulAssign => {}
-            AssignOp::DivAssign => {}
-            AssignOp::ModAssign => {}
-            AssignOp::LShiftAssign => {}
-            AssignOp::RShiftAssign => {}
-            AssignOp::ZeroFillRShiftAssign => {}
-            AssignOp::BitOrAssign => {}
-            AssignOp::BitXorAssign => {}
-            AssignOp::BitAndAssign => {}
-            AssignOp::ExpAssign => {}
-            AssignOp::AndAssign => {}
-            AssignOp::OrAssign => {}
-            AssignOp::NullishAssign => {}
+            AssignOp::Assign => AssignOp::Assign,
+            AssignOp::AddAssign => AssignOp::AddAssign,
+            AssignOp::SubAssign => AssignOp::SubAssign,
+            AssignOp::MulAssign => AssignOp::MulAssign,
+            AssignOp::DivAssign => AssignOp::DivAssign,
+            AssignOp::ModAssign => AssignOp::ModAssign,
+            AssignOp::LShiftAssign => AssignOp::LShiftAssign,
+            AssignOp::RShiftAssign => AssignOp::RShiftAssign,
+            AssignOp::ZeroFillRShiftAssign => AssignOp::ZeroFillRShiftAssign,
+            AssignOp::BitOrAssign => AssignOp::BitOrAssign,
+            AssignOp::BitXorAssign => AssignOp::BitXorAssign,
+            AssignOp::BitAndAssign => AssignOp::BitAndAssign,
+            AssignOp::ExpAssign => AssignOp::ExpAssign,
+            AssignOp::AndAssign => AssignOp::AndAssign,
+            AssignOp::OrAssign => AssignOp::OrAssign,
+            AssignOp::NullishAssign => AssignOp::NullishAssign,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignPat {
-    #[doc = "Calls [VisitAll`::visit_assign_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_assign_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignPat {
+    #[doc = "Calls [FoldAstPath`::fold_assign_pat`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_assign_pat(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AssignPat { span, left, right } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Pat> as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AssignPat(self::fields::AssignPatField::Left));
+                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPat(
+                        self::fields::AssignPatField::Right,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AssignPat { span, left, right }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignPatProp {
-    #[doc = "Calls [VisitAll`::visit_assign_pat_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_assign_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignPatProp {
+    #[doc = "Calls [FoldAstPath`::fold_assign_pat_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_assign_pat_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AssignPatProp { span, key, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
+                        self::fields::AssignPatPropField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <BindingIdent as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
+                        self::fields::AssignPatPropField::Key,
+                    ));
+                    <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignPatProp(
+                        self::fields::AssignPatPropField::Value,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AssignPatProp { span, key, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignProp {
-    #[doc = "Calls [VisitAll`::visit_assign_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_assign_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignProp {
+    #[doc = "Calls [FoldAstPath`::fold_assign_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_assign_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AssignProp { span, key, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
+                        self::fields::AssignPropField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
+                        self::fields::AssignPropField::Key,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignProp(
+                        self::fields::AssignPropField::Value,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AssignProp { span, key, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignTarget {
-    #[doc = "Calls [VisitAll`::visit_assign_target`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_assign_target(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignTarget {
+    #[doc = "Calls [FoldAstPath`::fold_assign_target`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_assign_target(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AssignTarget::Simple { 0: _field_0 } => {
-                <SimpleAssignTarget as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
+                    self::fields::AssignTargetField::Simple,
+                ));
+                let _field_0 = <SimpleAssignTarget as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AssignTarget::Simple { 0: _field_0 }
             }
             AssignTarget::Pat { 0: _field_0 } => {
-                <AssignTargetPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTarget(
+                    self::fields::AssignTargetField::Pat,
+                ));
+                let _field_0 = <AssignTargetPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AssignTarget::Pat { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AssignTargetPat {
-    #[doc = "Calls [VisitAll`::visit_assign_target_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_assign_target_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AssignTargetPat {
+    #[doc = "Calls [FoldAstPath`::fold_assign_target_pat`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_assign_target_pat(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AssignTargetPat::Array { 0: _field_0 } => {
-                <ArrayPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
+                    self::fields::AssignTargetPatField::Array,
+                ));
+                let _field_0 = <ArrayPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AssignTargetPat::Array { 0: _field_0 }
             }
             AssignTargetPat::Object { 0: _field_0 } => {
-                <ObjectPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
+                    self::fields::AssignTargetPatField::Object,
+                ));
+                let _field_0 = <ObjectPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AssignTargetPat::Object { 0: _field_0 }
             }
             AssignTargetPat::Invalid { 0: _field_0 } => {
-                <Invalid as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::AssignTargetPat(
+                    self::fields::AssignTargetPatField::Invalid,
+                ));
+                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                AssignTargetPat::Invalid { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AutoAccessor {
-    #[doc = "Calls [VisitAll`::visit_auto_accessor`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_auto_accessor(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AutoAccessor {
+    #[doc = "Calls [FoldAstPath`::fold_auto_accessor`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_auto_accessor(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AutoAccessor {
                 span,
@@ -147880,76 +123418,164 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for AutoAccessor {
                 is_override,
                 definite,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Key as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Key,
+                    ));
+                    <Key as FoldWithAstPath<V>>::fold_with_ast_path(key, visitor, &mut *__ast_path)
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Value,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Decorator> as VisitAllWith<V>>::visit_with(decorators, visitor)
+                let decorators = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Accessibility> as VisitAllWith<V>>::visit_with(accessibility, visitor)
+                let accessibility = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::AutoAccessor(
+                        self::fields::AutoAccessorField::Accessibility,
+                    ));
+                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AutoAccessor {
+                    span,
+                    key,
+                    value,
+                    type_ann,
+                    is_static,
+                    decorators,
+                    accessibility,
+                    is_abstract,
+                    is_override,
+                    definite,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AwaitExpr {
-    #[doc = "Calls [VisitAll`::visit_await_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_await_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for AwaitExpr {
+    #[doc = "Calls [FoldAstPath`::fold_await_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_await_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             AwaitExpr { span, arg } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(arg, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::AwaitExpr(self::fields::AwaitExprField::Arg));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                AwaitExpr { span, arg }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BigInt {
-    #[doc = "Calls [VisitAll`::visit_big_int`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_big_int(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BigInt {
+    #[doc = "Calls [FoldAstPath`::fold_big_int`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_big_int(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             BigInt { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<BigIntValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Value));
+                    <Box<BigIntValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BigInt(self::fields::BigIntField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                BigInt { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BinExpr {
-    #[doc = "Calls [VisitAll`::visit_bin_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_bin_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinExpr {
+    #[doc = "Calls [FoldAstPath`::fold_bin_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_bin_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             BinExpr {
                 span,
@@ -147957,158 +123583,270 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for BinExpr {
                 left,
                 right,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <BinaryOp as VisitAllWith<V>>::visit_with(op, visitor)
+                let op = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Op));
+                    <BinaryOp as FoldWithAstPath<V>>::fold_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Left));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BinExpr(self::fields::BinExprField::Right));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                BinExpr {
+                    span,
+                    op,
+                    left,
+                    right,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BinaryOp {
-    #[doc = "Calls [VisitAll`::visit_binary_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_binary_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BinaryOp {
+    #[doc = "Calls [FoldAstPath`::fold_binary_op`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_binary_op(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            BinaryOp::EqEq => {}
-            BinaryOp::NotEq => {}
-            BinaryOp::EqEqEq => {}
-            BinaryOp::NotEqEq => {}
-            BinaryOp::Lt => {}
-            BinaryOp::LtEq => {}
-            BinaryOp::Gt => {}
-            BinaryOp::GtEq => {}
-            BinaryOp::LShift => {}
-            BinaryOp::RShift => {}
-            BinaryOp::ZeroFillRShift => {}
-            BinaryOp::Add => {}
-            BinaryOp::Sub => {}
-            BinaryOp::Mul => {}
-            BinaryOp::Div => {}
-            BinaryOp::Mod => {}
-            BinaryOp::BitOr => {}
-            BinaryOp::BitXor => {}
-            BinaryOp::BitAnd => {}
-            BinaryOp::LogicalOr => {}
-            BinaryOp::LogicalAnd => {}
-            BinaryOp::In => {}
-            BinaryOp::InstanceOf => {}
-            BinaryOp::Exp => {}
-            BinaryOp::NullishCoalescing => {}
+            BinaryOp::EqEq => BinaryOp::EqEq,
+            BinaryOp::NotEq => BinaryOp::NotEq,
+            BinaryOp::EqEqEq => BinaryOp::EqEqEq,
+            BinaryOp::NotEqEq => BinaryOp::NotEqEq,
+            BinaryOp::Lt => BinaryOp::Lt,
+            BinaryOp::LtEq => BinaryOp::LtEq,
+            BinaryOp::Gt => BinaryOp::Gt,
+            BinaryOp::GtEq => BinaryOp::GtEq,
+            BinaryOp::LShift => BinaryOp::LShift,
+            BinaryOp::RShift => BinaryOp::RShift,
+            BinaryOp::ZeroFillRShift => BinaryOp::ZeroFillRShift,
+            BinaryOp::Add => BinaryOp::Add,
+            BinaryOp::Sub => BinaryOp::Sub,
+            BinaryOp::Mul => BinaryOp::Mul,
+            BinaryOp::Div => BinaryOp::Div,
+            BinaryOp::Mod => BinaryOp::Mod,
+            BinaryOp::BitOr => BinaryOp::BitOr,
+            BinaryOp::BitXor => BinaryOp::BitXor,
+            BinaryOp::BitAnd => BinaryOp::BitAnd,
+            BinaryOp::LogicalOr => BinaryOp::LogicalOr,
+            BinaryOp::LogicalAnd => BinaryOp::LogicalAnd,
+            BinaryOp::In => BinaryOp::In,
+            BinaryOp::InstanceOf => BinaryOp::InstanceOf,
+            BinaryOp::Exp => BinaryOp::Exp,
+            BinaryOp::NullishCoalescing => BinaryOp::NullishCoalescing,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BindingIdent {
-    #[doc = "Calls [VisitAll`::visit_binding_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_binding_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BindingIdent {
+    #[doc = "Calls [FoldAstPath`::fold_binding_ident`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_binding_ident(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             BindingIdent { id, type_ann } => {
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
+                        self::fields::BindingIdentField::Id,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BindingIdent(
+                        self::fields::BindingIdentField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                BindingIdent { id, type_ann }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BlockStmt {
-    #[doc = "Calls [VisitAll`::visit_block_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_block_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BlockStmt {
+    #[doc = "Calls [FoldAstPath`::fold_block_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_block_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             BlockStmt { span, ctxt, stmts } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BlockStmt(self::fields::BlockStmtField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Stmt> as VisitAllWith<V>>::visit_with(stmts, visitor)
+                let stmts = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmt(
+                        self::fields::BlockStmtField::Stmts(usize::MAX),
+                    ));
+                    <Vec<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        stmts,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                BlockStmt { span, ctxt, stmts }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BlockStmtOrExpr {
-    #[doc = "Calls [VisitAll`::visit_block_stmt_or_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_block_stmt_or_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BlockStmtOrExpr {
+    #[doc = "Calls [FoldAstPath`::fold_block_stmt_or_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_block_stmt_or_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             BlockStmtOrExpr::BlockStmt { 0: _field_0 } => {
-                <BlockStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
+                    self::fields::BlockStmtOrExprField::BlockStmt,
+                ));
+                let _field_0 = <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                BlockStmtOrExpr::BlockStmt { 0: _field_0 }
             }
             BlockStmtOrExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::BlockStmtOrExpr(
+                    self::fields::BlockStmtOrExprField::Expr,
+                ));
+                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                BlockStmtOrExpr::Expr { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Bool {
-    #[doc = "Calls [VisitAll`::visit_bool`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_bool(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Bool {
+    #[doc = "Calls [FoldAstPath`::fold_bool`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_bool(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Bool { span, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Bool(self::fields::BoolField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Bool { span, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BreakStmt {
-    #[doc = "Calls [VisitAll`::visit_break_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_break_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BreakStmt {
+    #[doc = "Calls [FoldAstPath`::fold_break_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_break_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             BreakStmt { span, label } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::BreakStmt(self::fields::BreakStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(label, visitor)
+                let label = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::BreakStmt(
+                        self::fields::BreakStmtField::Label,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                BreakStmt { span, label }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CallExpr {
-    #[doc = "Calls [VisitAll`::visit_call_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_call_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CallExpr {
+    #[doc = "Calls [FoldAstPath`::fold_call_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_call_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CallExpr {
                 span,
@@ -148117,76 +123855,158 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for CallExpr {
                 args,
                 type_args,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Callee as VisitAllWith<V>>::visit_with(callee, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ExprOrSpread> as VisitAllWith<V>>::visit_with(args, visitor)
+                let callee = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CallExpr(self::fields::CallExprField::Callee));
+                    <Callee as FoldWithAstPath<V>>::fold_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
+                        self::fields::CallExprField::Args(usize::MAX),
+                    ));
+                    <Vec<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CallExpr(
+                        self::fields::CallExprField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
+                CallExpr {
+                    span,
+                    ctxt,
+                    callee,
+                    args,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Callee {
-    #[doc = "Calls [VisitAll`::visit_callee`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_callee(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Callee {
+    #[doc = "Calls [FoldAstPath`::fold_callee`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_callee(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Callee::Super { 0: _field_0 } => {
-                <Super as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Super));
+                let _field_0 = <Super as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Callee::Super { 0: _field_0 }
             }
             Callee::Import { 0: _field_0 } => {
-                <Import as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Import));
+                let _field_0 = <Import as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Callee::Import { 0: _field_0 }
             }
             Callee::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Callee(self::fields::CalleeField::Expr));
+                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Callee::Expr { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CatchClause {
-    #[doc = "Calls [VisitAll`::visit_catch_clause`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_catch_clause(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CatchClause {
+    #[doc = "Calls [FoldAstPath`::fold_catch_clause`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_catch_clause(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CatchClause { span, param, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
+                        self::fields::CatchClauseField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Pat> as VisitAllWith<V>>::visit_with(param, visitor)
+                let param = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
+                        self::fields::CatchClauseField::Param,
+                    ));
+                    <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <BlockStmt as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::CatchClause(
+                        self::fields::CatchClauseField::Body,
+                    ));
+                    <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CatchClause { span, param, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Class {
-    #[doc = "Calls [VisitAll`::visit_class`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Class {
+    #[doc = "Calls [FoldAstPath`::fold_class`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Class {
                 span,
@@ -148199,127 +124019,294 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Class {
                 super_type_params,
                 implements,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Class(self::fields::ClassField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Decorator> as VisitAllWith<V>>::visit_with(decorators, visitor)
+                let decorators = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ClassMember> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::Body(usize::MAX),
+                    ));
+                    <Vec<ClassMember> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(super_class, visitor)
+                let super_class = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Class(self::fields::ClassField::SuperClass));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        super_class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Class(self::fields::ClassField::TypeParams));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        super_type_params,
+                let super_type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::SuperTypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (super_type_params , visitor , & mut * __ast_path)
+                };
+                let implements = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Class(
+                        self::fields::ClassField::Implements(usize::MAX),
+                    ));
+                    <Vec<TsExprWithTypeArgs> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        implements,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Vec<TsExprWithTypeArgs> as VisitAllWith<V>>::visit_with(implements, visitor)
-                };
+                Class {
+                    span,
+                    ctxt,
+                    decorators,
+                    body,
+                    super_class,
+                    is_abstract,
+                    type_params,
+                    super_type_params,
+                    implements,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassDecl {
-    #[doc = "Calls [VisitAll`::visit_class_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassDecl {
+    #[doc = "Calls [FoldAstPath`::fold_class_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ClassDecl {
                 ident,
                 declare,
                 class,
             } => {
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(ident, visitor)
+                let ident = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
+                        self::fields::ClassDeclField::Ident,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Class> as VisitAllWith<V>>::visit_with(class, visitor)
+                let class = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassDecl(
+                        self::fields::ClassDeclField::Class,
+                    ));
+                    <Box<Class> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ClassDecl {
+                    ident,
+                    declare,
+                    class,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassExpr {
-    #[doc = "Calls [VisitAll`::visit_class_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassExpr {
+    #[doc = "Calls [FoldAstPath`::fold_class_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ClassExpr { ident, class } => {
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(ident, visitor)
+                let ident = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
+                        self::fields::ClassExprField::Ident,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Class> as VisitAllWith<V>>::visit_with(class, visitor)
+                let class = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassExpr(
+                        self::fields::ClassExprField::Class,
+                    ));
+                    <Box<Class> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        class,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ClassExpr { ident, class }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassMember {
-    #[doc = "Calls [VisitAll`::visit_class_member`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class_member(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassMember {
+    #[doc = "Calls [FoldAstPath`::fold_class_member`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class_member(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ClassMember::Constructor { 0: _field_0 } => {
-                <Constructor as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::Constructor,
+                ));
+                let _field_0 = <Constructor as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::Constructor { 0: _field_0 }
             }
             ClassMember::Method { 0: _field_0 } => {
-                <ClassMethod as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::Method,
+                ));
+                let _field_0 = <ClassMethod as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::Method { 0: _field_0 }
             }
             ClassMember::PrivateMethod { 0: _field_0 } => {
-                <PrivateMethod as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::PrivateMethod,
+                ));
+                let _field_0 = <PrivateMethod as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::PrivateMethod { 0: _field_0 }
             }
             ClassMember::ClassProp { 0: _field_0 } => {
-                <ClassProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::ClassProp,
+                ));
+                let _field_0 = <ClassProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::ClassProp { 0: _field_0 }
             }
             ClassMember::PrivateProp { 0: _field_0 } => {
-                <PrivateProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::PrivateProp,
+                ));
+                let _field_0 = <PrivateProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::PrivateProp { 0: _field_0 }
             }
             ClassMember::TsIndexSignature { 0: _field_0 } => {
-                <TsIndexSignature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::TsIndexSignature,
+                ));
+                let _field_0 = <TsIndexSignature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::TsIndexSignature { 0: _field_0 }
             }
             ClassMember::Empty { 0: _field_0 } => {
-                <EmptyStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::Empty,
+                ));
+                let _field_0 = <EmptyStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::Empty { 0: _field_0 }
             }
             ClassMember::StaticBlock { 0: _field_0 } => {
-                <StaticBlock as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::StaticBlock,
+                ));
+                let _field_0 = <StaticBlock as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::StaticBlock { 0: _field_0 }
             }
             ClassMember::AutoAccessor { 0: _field_0 } => {
-                <AutoAccessor as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMember(
+                    self::fields::ClassMemberField::AutoAccessor,
+                ));
+                let _field_0 = <AutoAccessor as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ClassMember::AutoAccessor { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassMethod {
-    #[doc = "Calls [VisitAll`::visit_class_method`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class_method(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassMethod {
+    #[doc = "Calls [FoldAstPath`::fold_class_method`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class_method(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ClassMethod {
                 span,
@@ -148332,32 +124319,80 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassMethod {
                 is_optional,
                 is_override,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Key,
+                    ));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Function> as VisitAllWith<V>>::visit_with(function, visitor)
+                let function = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Function,
+                    ));
+                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MethodKind as VisitAllWith<V>>::visit_with(kind, visitor)
+                let kind = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Kind,
+                    ));
+                    <MethodKind as FoldWithAstPath<V>>::fold_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Accessibility> as VisitAllWith<V>>::visit_with(accessibility, visitor)
+                let accessibility = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassMethod(
+                        self::fields::ClassMethodField::Accessibility,
+                    ));
+                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ClassMethod {
+                    span,
+                    key,
+                    function,
+                    kind,
+                    is_static,
+                    accessibility,
+                    is_abstract,
+                    is_optional,
+                    is_override,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassProp {
-    #[doc = "Calls [VisitAll`::visit_class_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ClassProp {
+    #[doc = "Calls [FoldAstPath`::fold_class_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ClassProp {
                 span,
@@ -148374,54 +124409,128 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ClassProp {
                 declare,
                 definite,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ClassProp(self::fields::ClassPropField::Key));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::Value,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Decorator> as VisitAllWith<V>>::visit_with(decorators, visitor)
+                let decorators = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Accessibility> as VisitAllWith<V>>::visit_with(accessibility, visitor)
+                let accessibility = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ClassProp(
+                        self::fields::ClassPropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ClassProp {
+                    span,
+                    key,
+                    value,
+                    type_ann,
+                    is_static,
+                    decorators,
+                    accessibility,
+                    is_abstract,
+                    is_optional,
+                    is_override,
+                    readonly,
+                    declare,
+                    definite,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ComputedPropName {
-    #[doc = "Calls [VisitAll`::visit_computed_prop_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_computed_prop_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ComputedPropName {
+    #[doc = "Calls [FoldAstPath`::fold_computed_prop_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_computed_prop_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ComputedPropName { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
+                        self::fields::ComputedPropNameField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ComputedPropName(
+                        self::fields::ComputedPropNameField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ComputedPropName { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CondExpr {
-    #[doc = "Calls [VisitAll`::visit_cond_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_cond_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for CondExpr {
+    #[doc = "Calls [FoldAstPath`::fold_cond_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_cond_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             CondExpr {
                 span,
@@ -148429,29 +124538,61 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for CondExpr {
                 cons,
                 alt,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(test, visitor)
+                let test = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Test));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(cons, visitor)
+                let cons = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Cons));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(alt, visitor)
+                let alt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::CondExpr(self::fields::CondExprField::Alt));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        alt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                CondExpr {
+                    span,
+                    test,
+                    cons,
+                    alt,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Constructor {
-    #[doc = "Calls [VisitAll`::visit_constructor`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_constructor(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Constructor {
+    #[doc = "Calls [FoldAstPath`::fold_constructor`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_constructor(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Constructor {
                 span,
@@ -148462,204 +124603,418 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Constructor {
                 accessibility,
                 is_optional,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Key,
+                    ));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ParamOrTsParamProp> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Params(usize::MAX),
+                    ));
+                    <Vec<ParamOrTsParamProp> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<BlockStmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Body,
+                    ));
+                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Accessibility> as VisitAllWith<V>>::visit_with(accessibility, visitor)
+                let accessibility = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Constructor(
+                        self::fields::ConstructorField::Accessibility,
+                    ));
+                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Constructor {
+                    span,
+                    ctxt,
+                    key,
+                    params,
+                    body,
+                    accessibility,
+                    is_optional,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ContinueStmt {
-    #[doc = "Calls [VisitAll`::visit_continue_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_continue_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ContinueStmt {
+    #[doc = "Calls [FoldAstPath`::fold_continue_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_continue_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ContinueStmt { span, label } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
+                        self::fields::ContinueStmtField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(label, visitor)
+                let label = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ContinueStmt(
+                        self::fields::ContinueStmtField::Label,
+                    ));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ContinueStmt { span, label }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DebuggerStmt {
-    #[doc = "Calls [VisitAll`::visit_debugger_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_debugger_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DebuggerStmt {
+    #[doc = "Calls [FoldAstPath`::fold_debugger_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_debugger_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DebuggerStmt { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DebuggerStmt(
+                        self::fields::DebuggerStmtField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                DebuggerStmt { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Decl {
-    #[doc = "Calls [VisitAll`::visit_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Decl {
+    #[doc = "Calls [FoldAstPath`::fold_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Decl::Class { 0: _field_0 } => {
-                <ClassDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Class));
+                let _field_0 = <ClassDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::Class { 0: _field_0 }
             }
             Decl::Fn { 0: _field_0 } => {
-                <FnDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Fn));
+                let _field_0 = <FnDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::Fn { 0: _field_0 }
             }
             Decl::Var { 0: _field_0 } => {
-                <Box<VarDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Var));
+                let _field_0 = <Box<VarDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::Var { 0: _field_0 }
             }
             Decl::Using { 0: _field_0 } => {
-                <Box<UsingDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::Using));
+                let _field_0 = <Box<UsingDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::Using { 0: _field_0 }
             }
             Decl::TsInterface { 0: _field_0 } => {
-                <Box<TsInterfaceDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsInterface));
+                let _field_0 = <Box<TsInterfaceDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::TsInterface { 0: _field_0 }
             }
             Decl::TsTypeAlias { 0: _field_0 } => {
-                <Box<TsTypeAliasDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Decl(self::fields::DeclField::TsTypeAlias));
+                let _field_0 = <Box<TsTypeAliasDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::TsTypeAlias { 0: _field_0 }
             }
             Decl::TsEnum { 0: _field_0 } => {
-                <Box<TsEnumDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsEnum));
+                let _field_0 = <Box<TsEnumDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::TsEnum { 0: _field_0 }
             }
             Decl::TsModule { 0: _field_0 } => {
-                <Box<TsModuleDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Decl(self::fields::DeclField::TsModule));
+                let _field_0 = <Box<TsModuleDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Decl::TsModule { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Decorator {
-    #[doc = "Calls [VisitAll`::visit_decorator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_decorator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Decorator {
+    #[doc = "Calls [FoldAstPath`::fold_decorator`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_decorator(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Decorator { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Decorator(self::fields::DecoratorField::Expr));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Decorator { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DefaultDecl {
-    #[doc = "Calls [VisitAll`::visit_default_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_default_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DefaultDecl {
+    #[doc = "Calls [FoldAstPath`::fold_default_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_default_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DefaultDecl::Class { 0: _field_0 } => {
-                <ClassExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
+                    self::fields::DefaultDeclField::Class,
+                ));
+                let _field_0 = <ClassExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DefaultDecl::Class { 0: _field_0 }
             }
             DefaultDecl::Fn { 0: _field_0 } => {
-                <FnExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
+                    self::fields::DefaultDeclField::Fn,
+                ));
+                let _field_0 = <FnExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DefaultDecl::Fn { 0: _field_0 }
             }
             DefaultDecl::TsInterfaceDecl { 0: _field_0 } => {
-                <Box<TsInterfaceDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::DefaultDecl(
+                    self::fields::DefaultDeclField::TsInterfaceDecl,
+                ));
+                let _field_0 = <Box<TsInterfaceDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                DefaultDecl::TsInterfaceDecl { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DoWhileStmt {
-    #[doc = "Calls [VisitAll`::visit_do_while_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_do_while_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for DoWhileStmt {
+    #[doc = "Calls [FoldAstPath`::fold_do_while_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_do_while_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             DoWhileStmt { span, test, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
+                        self::fields::DoWhileStmtField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(test, visitor)
+                let test = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
+                        self::fields::DoWhileStmtField::Test,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::DoWhileStmt(
+                        self::fields::DoWhileStmtField::Body,
+                    ));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                DoWhileStmt { span, test, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for EmptyStmt {
-    #[doc = "Calls [VisitAll`::visit_empty_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_empty_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for EmptyStmt {
+    #[doc = "Calls [FoldAstPath`::fold_empty_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_empty_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             EmptyStmt { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::EmptyStmt(self::fields::EmptyStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                EmptyStmt { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for EsVersion {
-    #[doc = "Calls [VisitAll`::visit_es_version`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_es_version(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for EsVersion {
+    #[doc = "Calls [FoldAstPath`::fold_es_version`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_es_version(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            EsVersion::Es3 => {}
-            EsVersion::Es5 => {}
-            EsVersion::Es2015 => {}
-            EsVersion::Es2016 => {}
-            EsVersion::Es2017 => {}
-            EsVersion::Es2018 => {}
-            EsVersion::Es2019 => {}
-            EsVersion::Es2020 => {}
-            EsVersion::Es2021 => {}
-            EsVersion::Es2022 => {}
-            EsVersion::EsNext => {}
+            EsVersion::Es3 => EsVersion::Es3,
+            EsVersion::Es5 => EsVersion::Es5,
+            EsVersion::Es2015 => EsVersion::Es2015,
+            EsVersion::Es2016 => EsVersion::Es2016,
+            EsVersion::Es2017 => EsVersion::Es2017,
+            EsVersion::Es2018 => EsVersion::Es2018,
+            EsVersion::Es2019 => EsVersion::Es2019,
+            EsVersion::Es2020 => EsVersion::Es2020,
+            EsVersion::Es2021 => EsVersion::Es2021,
+            EsVersion::Es2022 => EsVersion::Es2022,
+            EsVersion::EsNext => EsVersion::EsNext,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportAll {
-    #[doc = "Calls [VisitAll`::visit_export_all`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_all(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportAll {
+    #[doc = "Calls [FoldAstPath`::fold_export_all`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_all(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportAll {
                 span,
@@ -148667,99 +125022,187 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportAll {
                 type_only,
                 with,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Str> as VisitAllWith<V>>::visit_with(src, visitor)
+                let src = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::Src));
+                    <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<ObjectLit>> as VisitAllWith<V>>::visit_with(with, visitor)
+                let with = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExportAll(self::fields::ExportAllField::With));
+                    <Option<Box<ObjectLit>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExportAll {
+                    span,
+                    src,
+                    type_only,
+                    with,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportDecl {
-    #[doc = "Calls [VisitAll`::visit_export_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDecl {
+    #[doc = "Calls [FoldAstPath`::fold_export_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportDecl { span, decl } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
+                        self::fields::ExportDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Decl as VisitAllWith<V>>::visit_with(decl, visitor)
+                let decl = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDecl(
+                        self::fields::ExportDeclField::Decl,
+                    ));
+                    <Decl as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExportDecl { span, decl }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportDefaultDecl {
-    #[doc = "Calls [VisitAll`::visit_export_default_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_default_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDefaultDecl {
+    #[doc = "Calls [FoldAstPath`::fold_export_default_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_default_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportDefaultDecl { span, decl } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
+                        self::fields::ExportDefaultDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <DefaultDecl as VisitAllWith<V>>::visit_with(decl, visitor)
+                let decl = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultDecl(
+                        self::fields::ExportDefaultDeclField::Decl,
+                    ));
+                    <DefaultDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExportDefaultDecl { span, decl }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportDefaultExpr {
-    #[doc = "Calls [VisitAll`::visit_export_default_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_default_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDefaultExpr {
+    #[doc = "Calls [FoldAstPath`::fold_export_default_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_default_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportDefaultExpr { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
+                        self::fields::ExportDefaultExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportDefaultExpr(
+                        self::fields::ExportDefaultExprField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExportDefaultExpr { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportDefaultSpecifier {
-    #[doc = "Calls [VisitAll`::visit_export_default_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_default_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportDefaultSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_export_default_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_default_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportDefaultSpecifier { exported } => {
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(exported, visitor)
+                let exported = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportDefaultSpecifier(
+                            self::fields::ExportDefaultSpecifierField::Exported,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        exported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExportDefaultSpecifier { exported }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportNamedSpecifier {
-    #[doc = "Calls [VisitAll`::visit_export_named_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_named_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportNamedSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_export_named_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_named_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportNamedSpecifier {
                 span,
@@ -148767,290 +125210,729 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportNamedSpecifier {
                 exported,
                 is_type_only,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
+                            self::fields::ExportNamedSpecifierField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ModuleExportName as VisitAllWith<V>>::visit_with(orig, visitor)
+                let orig = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
+                            self::fields::ExportNamedSpecifierField::Orig,
+                        ));
+                    <ModuleExportName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        orig,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<ModuleExportName> as VisitAllWith<V>>::visit_with(exported, visitor)
+                let exported = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamedSpecifier(
+                            self::fields::ExportNamedSpecifierField::Exported,
+                        ));
+                    <Option<ModuleExportName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        exported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExportNamedSpecifier {
+                    span,
+                    orig,
+                    exported,
+                    is_type_only,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportNamespaceSpecifier {
-    #[doc = "Calls [VisitAll`::visit_export_namespace_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_namespace_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportNamespaceSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_export_namespace_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_namespace_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportNamespaceSpecifier { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
+                            self::fields::ExportNamespaceSpecifierField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ModuleExportName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ExportNamespaceSpecifier(
+                            self::fields::ExportNamespaceSpecifierField::Name,
+                        ));
+                    <ModuleExportName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExportNamespaceSpecifier { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExportSpecifier {
-    #[doc = "Calls [VisitAll`::visit_export_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExportSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_export_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExportSpecifier::Namespace { 0: _field_0 } => {
-                <ExportNamespaceSpecifier as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
+                    self::fields::ExportSpecifierField::Namespace,
+                ));
+                let _field_0 = <ExportNamespaceSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ExportSpecifier::Namespace { 0: _field_0 }
             }
             ExportSpecifier::Default { 0: _field_0 } => {
-                <ExportDefaultSpecifier as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
+                    self::fields::ExportSpecifierField::Default,
+                ));
+                let _field_0 = <ExportDefaultSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ExportSpecifier::Default { 0: _field_0 }
             }
             ExportSpecifier::Named { 0: _field_0 } => {
-                <ExportNamedSpecifier as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ExportSpecifier(
+                    self::fields::ExportSpecifierField::Named,
+                ));
+                let _field_0 = <ExportNamedSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ExportSpecifier::Named { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Expr {
-    #[doc = "Calls [VisitAll`::visit_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Expr {
+    #[doc = "Calls [FoldAstPath`::fold_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Expr::This { 0: _field_0 } => {
-                <ThisExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::This));
+                let _field_0 = <ThisExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::This { 0: _field_0 }
             }
             Expr::Array { 0: _field_0 } => {
-                <ArrayLit as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Array));
+                let _field_0 = <ArrayLit as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Array { 0: _field_0 }
             }
             Expr::Object { 0: _field_0 } => {
-                <ObjectLit as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Object));
+                let _field_0 = <ObjectLit as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Object { 0: _field_0 }
             }
             Expr::Fn { 0: _field_0 } => {
-                <FnExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Fn));
+                let _field_0 = <FnExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Fn { 0: _field_0 }
             }
             Expr::Unary { 0: _field_0 } => {
-                <UnaryExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Unary));
+                let _field_0 = <UnaryExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Unary { 0: _field_0 }
             }
             Expr::Update { 0: _field_0 } => {
-                <UpdateExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Update));
+                let _field_0 = <UpdateExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Update { 0: _field_0 }
             }
             Expr::Bin { 0: _field_0 } => {
-                <BinExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Bin));
+                let _field_0 = <BinExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Bin { 0: _field_0 }
             }
             Expr::Assign { 0: _field_0 } => {
-                <AssignExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Assign));
+                let _field_0 = <AssignExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Assign { 0: _field_0 }
             }
             Expr::Member { 0: _field_0 } => {
-                <MemberExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Member));
+                let _field_0 = <MemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Member { 0: _field_0 }
             }
             Expr::SuperProp { 0: _field_0 } => {
-                <SuperPropExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::SuperProp));
+                let _field_0 = <SuperPropExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::SuperProp { 0: _field_0 }
             }
             Expr::Cond { 0: _field_0 } => {
-                <CondExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Cond));
+                let _field_0 = <CondExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Cond { 0: _field_0 }
             }
             Expr::Call { 0: _field_0 } => {
-                <CallExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Call));
+                let _field_0 = <CallExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Call { 0: _field_0 }
             }
             Expr::New { 0: _field_0 } => {
-                <NewExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::New));
+                let _field_0 = <NewExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::New { 0: _field_0 }
             }
             Expr::Seq { 0: _field_0 } => {
-                <SeqExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Seq));
+                let _field_0 = <SeqExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Seq { 0: _field_0 }
             }
             Expr::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Ident));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Ident { 0: _field_0 }
             }
             Expr::Lit { 0: _field_0 } => {
-                <Lit as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Lit));
+                let _field_0 = <Lit as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Lit { 0: _field_0 }
             }
             Expr::Tpl { 0: _field_0 } => {
-                <Tpl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Tpl));
+                let _field_0 = <Tpl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Tpl { 0: _field_0 }
             }
             Expr::TaggedTpl { 0: _field_0 } => {
-                <TaggedTpl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TaggedTpl));
+                let _field_0 = <TaggedTpl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::TaggedTpl { 0: _field_0 }
             }
             Expr::Arrow { 0: _field_0 } => {
-                <ArrowExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Arrow));
+                let _field_0 = <ArrowExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Arrow { 0: _field_0 }
             }
             Expr::Class { 0: _field_0 } => {
-                <ClassExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Class));
+                let _field_0 = <ClassExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Class { 0: _field_0 }
             }
             Expr::Yield { 0: _field_0 } => {
-                <YieldExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Yield));
+                let _field_0 = <YieldExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Yield { 0: _field_0 }
             }
             Expr::MetaProp { 0: _field_0 } => {
-                <MetaPropExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::MetaProp));
+                let _field_0 = <MetaPropExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::MetaProp { 0: _field_0 }
             }
             Expr::Await { 0: _field_0 } => {
-                <AwaitExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Await));
+                let _field_0 = <AwaitExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Await { 0: _field_0 }
             }
             Expr::Paren { 0: _field_0 } => {
-                <ParenExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Paren));
+                let _field_0 = <ParenExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Paren { 0: _field_0 }
             }
             Expr::JSXMember { 0: _field_0 } => {
-                <JSXMemberExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxmember));
+                let _field_0 = <JSXMemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::JSXMember { 0: _field_0 }
             }
             Expr::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::JsxnamespacedName,
+                ));
+                let _field_0 = <JSXNamespacedName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::JSXNamespacedName { 0: _field_0 }
             }
             Expr::JSXEmpty { 0: _field_0 } => {
-                <JSXEmptyExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxempty));
+                let _field_0 = <JSXEmptyExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::JSXEmpty { 0: _field_0 }
             }
             Expr::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxelement));
+                let _field_0 = <Box<JSXElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::JSXElement { 0: _field_0 }
             }
             Expr::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Expr(self::fields::ExprField::Jsxfragment));
+                let _field_0 = <JSXFragment as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::JSXFragment { 0: _field_0 }
             }
             Expr::TsTypeAssertion { 0: _field_0 } => {
-                <TsTypeAssertion as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::TsTypeAssertion,
+                ));
+                let _field_0 = <TsTypeAssertion as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::TsTypeAssertion { 0: _field_0 }
             }
             Expr::TsConstAssertion { 0: _field_0 } => {
-                <TsConstAssertion as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::TsConstAssertion,
+                ));
+                let _field_0 = <TsConstAssertion as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::TsConstAssertion { 0: _field_0 }
             }
             Expr::TsNonNull { 0: _field_0 } => {
-                <TsNonNullExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsNonNull));
+                let _field_0 = <TsNonNullExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::TsNonNull { 0: _field_0 }
             }
             Expr::TsAs { 0: _field_0 } => {
-                <TsAsExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::TsAs));
+                let _field_0 = <TsAsExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::TsAs { 0: _field_0 }
             }
             Expr::TsInstantiation { 0: _field_0 } => {
-                <TsInstantiation as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::Expr(
+                    self::fields::ExprField::TsInstantiation,
+                ));
+                let _field_0 = <TsInstantiation as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::TsInstantiation { 0: _field_0 }
             }
             Expr::TsSatisfies { 0: _field_0 } => {
-                <TsSatisfiesExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Expr(self::fields::ExprField::TsSatisfies));
+                let _field_0 = <TsSatisfiesExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::TsSatisfies { 0: _field_0 }
             }
             Expr::PrivateName { 0: _field_0 } => {
-                <PrivateName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Expr(self::fields::ExprField::PrivateName));
+                let _field_0 = <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::PrivateName { 0: _field_0 }
             }
             Expr::OptChain { 0: _field_0 } => {
-                <OptChainExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::OptChain));
+                let _field_0 = <OptChainExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::OptChain { 0: _field_0 }
             }
             Expr::Invalid { 0: _field_0 } => {
-                <Invalid as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Expr(self::fields::ExprField::Invalid));
+                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Expr::Invalid { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExprOrSpread {
-    #[doc = "Calls [VisitAll`::visit_expr_or_spread`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_expr_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExprOrSpread {
+    #[doc = "Calls [FoldAstPath`::fold_expr_or_spread`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_expr_or_spread(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExprOrSpread { spread, expr } => {
-                {
-                    <Option<swc_common::Span> as VisitAllWith<V>>::visit_with(spread, visitor)
+                let spread = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
+                        self::fields::ExprOrSpreadField::Spread,
+                    ));
+                    <Option<swc_common::Span> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        spread,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ExprOrSpread(
+                        self::fields::ExprOrSpreadField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExprOrSpread { spread, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ExprStmt {
-    #[doc = "Calls [VisitAll`::visit_expr_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_expr_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ExprStmt {
+    #[doc = "Calls [FoldAstPath`::fold_expr_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_expr_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ExprStmt { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ExprStmt(self::fields::ExprStmtField::Expr));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ExprStmt { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for FnDecl {
-    #[doc = "Calls [VisitAll`::visit_fn_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_fn_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FnDecl {
+    #[doc = "Calls [FoldAstPath`::fold_fn_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_fn_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             FnDecl {
                 ident,
                 declare,
                 function,
             } => {
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(ident, visitor)
+                let ident = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Ident));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Function> as VisitAllWith<V>>::visit_with(function, visitor)
+                let function = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnDecl(self::fields::FnDeclField::Function));
+                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                FnDecl {
+                    ident,
+                    declare,
+                    function,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for FnExpr {
-    #[doc = "Calls [VisitAll`::visit_fn_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_fn_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for FnExpr {
+    #[doc = "Calls [FoldAstPath`::fold_fn_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_fn_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             FnExpr { ident, function } => {
-                {
-                    <Option<Ident> as VisitAllWith<V>>::visit_with(ident, visitor)
+                let ident = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Ident));
+                    <Option<Ident> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ident,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Function> as VisitAllWith<V>>::visit_with(function, visitor)
+                let function = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::FnExpr(self::fields::FnExprField::Function));
+                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                FnExpr { ident, function }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForHead {
-    #[doc = "Calls [VisitAll`::visit_for_head`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_for_head(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForHead {
+    #[doc = "Calls [FoldAstPath`::fold_for_head`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_for_head(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForHead::VarDecl { 0: _field_0 } => {
-                <Box<VarDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::ForHead(self::fields::ForHeadField::VarDecl));
+                let _field_0 = <Box<VarDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ForHead::VarDecl { 0: _field_0 }
             }
             ForHead::UsingDecl { 0: _field_0 } => {
-                <Box<UsingDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ForHead(
+                    self::fields::ForHeadField::UsingDecl,
+                ));
+                let _field_0 = <Box<UsingDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ForHead::UsingDecl { 0: _field_0 }
             }
             ForHead::Pat { 0: _field_0 } => {
-                <Box<Pat> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::ForHead(self::fields::ForHeadField::Pat));
+                let _field_0 = <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ForHead::Pat { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForInStmt {
-    #[doc = "Calls [VisitAll`::visit_for_in_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_for_in_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForInStmt {
+    #[doc = "Calls [FoldAstPath`::fold_for_in_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_for_in_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForInStmt {
                 span,
@@ -149058,29 +125940,62 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForInStmt {
                 right,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ForHead as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Left));
+                    <ForHead as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForInStmt(
+                        self::fields::ForInStmtField::Right,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForInStmt(self::fields::ForInStmtField::Body));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ForInStmt {
+                    span,
+                    left,
+                    right,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForOfStmt {
-    #[doc = "Calls [VisitAll`::visit_for_of_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_for_of_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForOfStmt {
+    #[doc = "Calls [FoldAstPath`::fold_for_of_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_for_of_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForOfStmt {
                 span,
@@ -149089,29 +126004,63 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForOfStmt {
                 right,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ForHead as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Left));
+                    <ForHead as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ForOfStmt(
+                        self::fields::ForOfStmtField::Right,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForOfStmt(self::fields::ForOfStmtField::Body));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ForOfStmt {
+                    span,
+                    is_await,
+                    left,
+                    right,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForStmt {
-    #[doc = "Calls [VisitAll`::visit_for_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_for_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ForStmt {
+    #[doc = "Calls [FoldAstPath`::fold_for_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_for_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ForStmt {
                 span,
@@ -149120,32 +126069,71 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ForStmt {
                 update,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<VarDeclOrExpr> as VisitAllWith<V>>::visit_with(init, visitor)
+                let init = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Init));
+                    <Option<VarDeclOrExpr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(test, visitor)
+                let test = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Test));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(update, visitor)
+                let update = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Update));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        update,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ForStmt(self::fields::ForStmtField::Body));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ForStmt {
+                    span,
+                    init,
+                    test,
+                    update,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Function {
-    #[doc = "Calls [VisitAll`::visit_function`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_function(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Function {
+    #[doc = "Calls [FoldAstPath`::fold_function`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_function(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Function {
                 params,
@@ -149158,41 +126146,97 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Function {
                 type_params,
                 return_type,
             } => {
-                {
-                    <Vec<Param> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::Params(usize::MAX),
+                    ));
+                    <Vec<Param> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Decorator> as VisitAllWith<V>>::visit_with(decorators, visitor)
+                let decorators = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<BlockStmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Function(self::fields::FunctionField::Body));
+                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(return_type, visitor)
+                let return_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Function(
+                        self::fields::FunctionField::ReturnType,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        return_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Function {
+                    params,
+                    decorators,
+                    span,
+                    ctxt,
+                    body,
+                    is_generator,
+                    is_async,
+                    type_params,
+                    return_type,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for GetterProp {
-    #[doc = "Calls [VisitAll`::visit_getter_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_getter_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for GetterProp {
+    #[doc = "Calls [FoldAstPath`::fold_getter_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_getter_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             GetterProp {
                 span,
@@ -149200,29 +126244,65 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for GetterProp {
                 type_ann,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::Key,
+                    ));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<BlockStmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::GetterProp(
+                        self::fields::GetterPropField::Body,
+                    ));
+                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                GetterProp {
+                    span,
+                    key,
+                    type_ann,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Ident {
-    #[doc = "Calls [VisitAll`::visit_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Ident {
+    #[doc = "Calls [FoldAstPath`::fold_ident`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ident(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Ident {
                 span,
@@ -149230,45 +126310,86 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Ident {
                 sym,
                 optional,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(sym, visitor)
+                let sym = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Ident(self::fields::IdentField::Sym));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        sym,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Ident {
+                    span,
+                    ctxt,
+                    sym,
+                    optional,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for IdentName {
-    #[doc = "Calls [VisitAll`::visit_ident_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ident_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for IdentName {
+    #[doc = "Calls [FoldAstPath`::fold_ident_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ident_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             IdentName { span, sym } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(sym, visitor)
+                let sym = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IdentName(self::fields::IdentNameField::Sym));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        sym,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                IdentName { span, sym }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for IfStmt {
-    #[doc = "Calls [VisitAll`::visit_if_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_if_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for IfStmt {
+    #[doc = "Calls [FoldAstPath`::fold_if_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_if_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             IfStmt {
                 span,
@@ -149276,48 +126397,95 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for IfStmt {
                 cons,
                 alt,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(test, visitor)
+                let test = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Test));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(cons, visitor)
+                let cons = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Cons));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Stmt>> as VisitAllWith<V>>::visit_with(alt, visitor)
+                let alt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::IfStmt(self::fields::IfStmtField::Alt));
+                    <Option<Box<Stmt>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        alt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                IfStmt {
+                    span,
+                    test,
+                    cons,
+                    alt,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Import {
-    #[doc = "Calls [VisitAll`::visit_import`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Import {
+    #[doc = "Calls [FoldAstPath`::fold_import`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Import { span, phase } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Import(self::fields::ImportField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ImportPhase as VisitAllWith<V>>::visit_with(phase, visitor)
+                let phase = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Import(self::fields::ImportField::Phase));
+                    <ImportPhase as FoldWithAstPath<V>>::fold_with_ast_path(
+                        phase,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Import { span, phase }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportDecl {
-    #[doc = "Calls [VisitAll`::visit_import_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportDecl {
+    #[doc = "Calls [FoldAstPath`::fold_import_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportDecl {
                 span,
@@ -149327,51 +126495,115 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportDecl {
                 with,
                 phase,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ImportSpecifier> as VisitAllWith<V>>::visit_with(specifiers, visitor)
+                let specifiers = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Specifiers(usize::MAX),
+                    ));
+                    <Vec<ImportSpecifier> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        specifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Str> as VisitAllWith<V>>::visit_with(src, visitor)
+                let src = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Src,
+                    ));
+                    <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<ObjectLit>> as VisitAllWith<V>>::visit_with(with, visitor)
+                let with = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::With,
+                    ));
+                    <Option<Box<ObjectLit>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <ImportPhase as VisitAllWith<V>>::visit_with(phase, visitor)
+                let phase = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportDecl(
+                        self::fields::ImportDeclField::Phase,
+                    ));
+                    <ImportPhase as FoldWithAstPath<V>>::fold_with_ast_path(
+                        phase,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportDecl {
+                    span,
+                    specifiers,
+                    src,
+                    type_only,
+                    with,
+                    phase,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportDefaultSpecifier {
-    #[doc = "Calls [VisitAll`::visit_import_default_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_default_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportDefaultSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_import_default_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_default_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportDefaultSpecifier { span, local } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
+                            self::fields::ImportDefaultSpecifierField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(local, visitor)
+                let local = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportDefaultSpecifier(
+                            self::fields::ImportDefaultSpecifierField::Local,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportDefaultSpecifier { span, local }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportNamedSpecifier {
-    #[doc = "Calls [VisitAll`::visit_import_named_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_named_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportNamedSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_import_named_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_named_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportNamedSpecifier {
                 span,
@@ -149379,247 +126611,487 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportNamedSpecifier {
                 imported,
                 is_type_only,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
+                            self::fields::ImportNamedSpecifierField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(local, visitor)
+                let local = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
+                            self::fields::ImportNamedSpecifierField::Local,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<ModuleExportName> as VisitAllWith<V>>::visit_with(imported, visitor)
+                let imported = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportNamedSpecifier(
+                            self::fields::ImportNamedSpecifierField::Imported,
+                        ));
+                    <Option<ModuleExportName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        imported,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportNamedSpecifier {
+                    span,
+                    local,
+                    imported,
+                    is_type_only,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportPhase {
-    #[doc = "Calls [VisitAll`::visit_import_phase`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_phase(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportPhase {
+    #[doc = "Calls [FoldAstPath`::fold_import_phase`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_phase(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            ImportPhase::Evaluation => {}
-            ImportPhase::Source => {}
-            ImportPhase::Defer => {}
+            ImportPhase::Evaluation => ImportPhase::Evaluation,
+            ImportPhase::Source => ImportPhase::Source,
+            ImportPhase::Defer => ImportPhase::Defer,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportSpecifier {
-    #[doc = "Calls [VisitAll`::visit_import_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_import_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportSpecifier::Named { 0: _field_0 } => {
-                <ImportNamedSpecifier as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
+                    self::fields::ImportSpecifierField::Named,
+                ));
+                let _field_0 = <ImportNamedSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ImportSpecifier::Named { 0: _field_0 }
             }
             ImportSpecifier::Default { 0: _field_0 } => {
-                <ImportDefaultSpecifier as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
+                    self::fields::ImportSpecifierField::Default,
+                ));
+                let _field_0 = <ImportDefaultSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ImportSpecifier::Default { 0: _field_0 }
             }
             ImportSpecifier::Namespace { 0: _field_0 } => {
-                <ImportStarAsSpecifier as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportSpecifier(
+                    self::fields::ImportSpecifierField::Namespace,
+                ));
+                let _field_0 = <ImportStarAsSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ImportSpecifier::Namespace { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportStarAsSpecifier {
-    #[doc = "Calls [VisitAll`::visit_import_star_as_specifier`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_star_as_specifier(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportStarAsSpecifier {
+    #[doc = "Calls [FoldAstPath`::fold_import_star_as_specifier`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_star_as_specifier(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportStarAsSpecifier { span, local } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
+                            self::fields::ImportStarAsSpecifierField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(local, visitor)
+                let local = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::ImportStarAsSpecifier(
+                            self::fields::ImportStarAsSpecifierField::Local,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        local,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportStarAsSpecifier { span, local }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportWith {
-    #[doc = "Calls [VisitAll`::visit_import_with`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_with(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportWith {
+    #[doc = "Calls [FoldAstPath`::fold_import_with`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_with(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportWith { span, values } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
+                        self::fields::ImportWithField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ImportWithItem> as VisitAllWith<V>>::visit_with(values, visitor)
+                let values = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWith(
+                        self::fields::ImportWithField::Values(usize::MAX),
+                    ));
+                    <Vec<ImportWithItem> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        values,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportWith { span, values }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ImportWithItem {
-    #[doc = "Calls [VisitAll`::visit_import_with_item`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_with_item(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ImportWithItem {
+    #[doc = "Calls [FoldAstPath`::fold_import_with_item`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_with_item(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ImportWithItem { key, value } => {
-                {
-                    <IdentName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
+                        self::fields::ImportWithItemField::Key,
+                    ));
+                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Str as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ImportWithItem(
+                        self::fields::ImportWithItemField::Value,
+                    ));
+                    <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ImportWithItem { key, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Invalid {
-    #[doc = "Calls [VisitAll`::visit_invalid`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_invalid(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Invalid {
+    #[doc = "Calls [FoldAstPath`::fold_invalid`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_invalid(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Invalid { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Invalid(self::fields::InvalidField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Invalid { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXAttr {
-    #[doc = "Calls [VisitAll`::visit_jsx_attr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_attr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttr {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_attr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_attr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXAttr { span, name, value } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <JSXAttrName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Name));
+                    <JSXAttrName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<JSXAttrValue> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXAttr(self::fields::JSXAttrField::Value));
+                    <Option<JSXAttrValue> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXAttr { span, name, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXAttrName {
-    #[doc = "Calls [VisitAll`::visit_jsx_attr_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_attr_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttrName {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_attr_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXAttrName::Ident { 0: _field_0 } => {
-                <IdentName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
+                    self::fields::JSXAttrNameField::Ident,
+                ));
+                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrName::Ident { 0: _field_0 }
             }
             JSXAttrName::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrName(
+                    self::fields::JSXAttrNameField::JsxnamespacedName,
+                ));
+                let _field_0 = <JSXNamespacedName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrName::JSXNamespacedName { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXAttrOrSpread {
-    #[doc = "Calls [VisitAll`::visit_jsx_attr_or_spread`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_attr_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttrOrSpread {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_or_spread`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_attr_or_spread(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXAttrOrSpread::JSXAttr { 0: _field_0 } => {
-                <JSXAttr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
+                    self::fields::JSXAttrOrSpreadField::Jsxattr,
+                ));
+                let _field_0 = <JSXAttr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrOrSpread::JSXAttr { 0: _field_0 }
             }
             JSXAttrOrSpread::SpreadElement { 0: _field_0 } => {
-                <SpreadElement as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrOrSpread(
+                    self::fields::JSXAttrOrSpreadField::SpreadElement,
+                ));
+                let _field_0 = <SpreadElement as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrOrSpread::SpreadElement { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXAttrValue {
-    #[doc = "Calls [VisitAll`::visit_jsx_attr_value`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_attr_value(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXAttrValue {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_value`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_attr_value(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXAttrValue::Lit { 0: _field_0 } => {
-                <Lit as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::Lit,
+                ));
+                let _field_0 = <Lit as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrValue::Lit { 0: _field_0 }
             }
             JSXAttrValue::JSXExprContainer { 0: _field_0 } => {
-                <JSXExprContainer as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::JsxexprContainer,
+                ));
+                let _field_0 = <JSXExprContainer as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrValue::JSXExprContainer { 0: _field_0 }
             }
             JSXAttrValue::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::Jsxelement,
+                ));
+                let _field_0 = <Box<JSXElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrValue::JSXElement { 0: _field_0 }
             }
             JSXAttrValue::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXAttrValue(
+                    self::fields::JSXAttrValueField::Jsxfragment,
+                ));
+                let _field_0 = <JSXFragment as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXAttrValue::JSXFragment { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXClosingElement {
-    #[doc = "Calls [VisitAll`::visit_jsx_closing_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_closing_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXClosingElement {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_closing_element`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_closing_element(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXClosingElement { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
+                        self::fields::JSXClosingElementField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <JSXElementName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingElement(
+                        self::fields::JSXClosingElementField::Name,
+                    ));
+                    <JSXElementName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXClosingElement { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXClosingFragment {
-    #[doc = "Calls [VisitAll`::visit_jsx_closing_fragment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_closing_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXClosingFragment {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_closing_fragment`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_closing_fragment(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXClosingFragment { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXClosingFragment(
+                        self::fields::JSXClosingFragmentField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXClosingFragment { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXElement {
-    #[doc = "Calls [VisitAll`::visit_jsx_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElement {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_element`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_element(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXElement {
                 span,
@@ -149627,127 +127099,275 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXElement {
                 children,
                 closing,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <JSXOpeningElement as VisitAllWith<V>>::visit_with(opening, visitor)
+                let opening = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Opening,
+                    ));
+                    <JSXOpeningElement as FoldWithAstPath<V>>::fold_with_ast_path(
+                        opening,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<JSXElementChild> as VisitAllWith<V>>::visit_with(children, visitor)
+                let children = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Children(usize::MAX),
+                    ));
+                    <Vec<JSXElementChild> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<JSXClosingElement> as VisitAllWith<V>>::visit_with(closing, visitor)
+                let closing = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElement(
+                        self::fields::JSXElementField::Closing,
+                    ));
+                    <Option<JSXClosingElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        closing,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXElement {
+                    span,
+                    opening,
+                    children,
+                    closing,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXElementChild {
-    #[doc = "Calls [VisitAll`::visit_jsx_element_child`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_element_child(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElementChild {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_element_child`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_element_child(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXElementChild::JSXText { 0: _field_0 } => {
-                <JSXText as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::Jsxtext,
+                ));
+                let _field_0 = <JSXText as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementChild::JSXText { 0: _field_0 }
             }
             JSXElementChild::JSXExprContainer { 0: _field_0 } => {
-                <JSXExprContainer as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::JsxexprContainer,
+                ));
+                let _field_0 = <JSXExprContainer as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementChild::JSXExprContainer { 0: _field_0 }
             }
             JSXElementChild::JSXSpreadChild { 0: _field_0 } => {
-                <JSXSpreadChild as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::JsxspreadChild,
+                ));
+                let _field_0 = <JSXSpreadChild as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementChild::JSXSpreadChild { 0: _field_0 }
             }
             JSXElementChild::JSXElement { 0: _field_0 } => {
-                <Box<JSXElement> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::Jsxelement,
+                ));
+                let _field_0 = <Box<JSXElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementChild::JSXElement { 0: _field_0 }
             }
             JSXElementChild::JSXFragment { 0: _field_0 } => {
-                <JSXFragment as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementChild(
+                    self::fields::JSXElementChildField::Jsxfragment,
+                ));
+                let _field_0 = <JSXFragment as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementChild::JSXFragment { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXElementName {
-    #[doc = "Calls [VisitAll`::visit_jsx_element_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_element_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXElementName {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_element_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_element_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXElementName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
+                    self::fields::JSXElementNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementName::Ident { 0: _field_0 }
             }
             JSXElementName::JSXMemberExpr { 0: _field_0 } => {
-                <JSXMemberExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
+                    self::fields::JSXElementNameField::JsxmemberExpr,
+                ));
+                let _field_0 = <JSXMemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementName::JSXMemberExpr { 0: _field_0 }
             }
             JSXElementName::JSXNamespacedName { 0: _field_0 } => {
-                <JSXNamespacedName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXElementName(
+                    self::fields::JSXElementNameField::JsxnamespacedName,
+                ));
+                let _field_0 = <JSXNamespacedName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXElementName::JSXNamespacedName { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXEmptyExpr {
-    #[doc = "Calls [VisitAll`::visit_jsx_empty_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_empty_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXEmptyExpr {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_empty_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_empty_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXEmptyExpr { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXEmptyExpr(
+                        self::fields::JSXEmptyExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXEmptyExpr { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXExpr {
-    #[doc = "Calls [VisitAll`::visit_jsx_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXExpr {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXExpr::JSXEmptyExpr { 0: _field_0 } => {
-                <JSXEmptyExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExpr(
+                    self::fields::JSXExprField::JsxemptyExpr,
+                ));
+                let _field_0 = <JSXEmptyExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXExpr::JSXEmptyExpr { 0: _field_0 }
             }
             JSXExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::JSXExpr(self::fields::JSXExprField::Expr));
+                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXExpr::Expr { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXExprContainer {
-    #[doc = "Calls [VisitAll`::visit_jsx_expr_container`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_expr_container(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXExprContainer {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_expr_container`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_expr_container(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXExprContainer { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
+                        self::fields::JSXExprContainerField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <JSXExpr as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXExprContainer(
+                        self::fields::JSXExprContainerField::Expr,
+                    ));
+                    <JSXExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXExprContainer { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXFragment {
-    #[doc = "Calls [VisitAll`::visit_jsx_fragment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXFragment {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_fragment`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_fragment(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXFragment {
                 span,
@@ -149755,90 +127375,192 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXFragment {
                 children,
                 closing,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <JSXOpeningFragment as VisitAllWith<V>>::visit_with(opening, visitor)
+                let opening = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Opening,
+                    ));
+                    <JSXOpeningFragment as FoldWithAstPath<V>>::fold_with_ast_path(
+                        opening,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<JSXElementChild> as VisitAllWith<V>>::visit_with(children, visitor)
+                let children = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Children(usize::MAX),
+                    ));
+                    <Vec<JSXElementChild> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        children,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <JSXClosingFragment as VisitAllWith<V>>::visit_with(closing, visitor)
+                let closing = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXFragment(
+                        self::fields::JSXFragmentField::Closing,
+                    ));
+                    <JSXClosingFragment as FoldWithAstPath<V>>::fold_with_ast_path(
+                        closing,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXFragment {
+                    span,
+                    opening,
+                    children,
+                    closing,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXMemberExpr {
-    #[doc = "Calls [VisitAll`::visit_jsx_member_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_member_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXMemberExpr {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_member_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_member_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXMemberExpr { span, obj, prop } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
+                        self::fields::JSXMemberExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <JSXObject as VisitAllWith<V>>::visit_with(obj, visitor)
+                let obj = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
+                        self::fields::JSXMemberExprField::Obj,
+                    ));
+                    <JSXObject as FoldWithAstPath<V>>::fold_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <IdentName as VisitAllWith<V>>::visit_with(prop, visitor)
+                let prop = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXMemberExpr(
+                        self::fields::JSXMemberExprField::Prop,
+                    ));
+                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXMemberExpr { span, obj, prop }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXNamespacedName {
-    #[doc = "Calls [VisitAll`::visit_jsx_namespaced_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_namespaced_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXNamespacedName {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_namespaced_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_namespaced_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXNamespacedName { span, ns, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
+                        self::fields::JSXNamespacedNameField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <IdentName as VisitAllWith<V>>::visit_with(ns, visitor)
+                let ns = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
+                        self::fields::JSXNamespacedNameField::Ns,
+                    ));
+                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ns,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <IdentName as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXNamespacedName(
+                        self::fields::JSXNamespacedNameField::Name,
+                    ));
+                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXNamespacedName { span, ns, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXObject {
-    #[doc = "Calls [VisitAll`::visit_jsx_object`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_object(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXObject {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_object`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_object(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXObject::JSXMemberExpr { 0: _field_0 } => {
-                <Box<JSXMemberExpr> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
+                    self::fields::JSXObjectField::JsxmemberExpr,
+                ));
+                let _field_0 = <Box<JSXMemberExpr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXObject::JSXMemberExpr { 0: _field_0 }
             }
             JSXObject::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXObject(
+                    self::fields::JSXObjectField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                JSXObject::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXOpeningElement {
-    #[doc = "Calls [VisitAll`::visit_jsx_opening_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_opening_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXOpeningElement {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_opening_element`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_opening_element(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXOpeningElement {
                 name,
@@ -149847,402 +127569,830 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXOpeningElement {
                 self_closing,
                 type_args,
             } => {
-                {
-                    <JSXElementName as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::Name,
+                    ));
+                    <JSXElementName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<JSXAttrOrSpread> as VisitAllWith<V>>::visit_with(attrs, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let attrs = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::Attrs(usize::MAX),
+                    ));
+                    <Vec<JSXAttrOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        attrs,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningElement(
+                        self::fields::JSXOpeningElementField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
+                JSXOpeningElement {
+                    name,
+                    span,
+                    attrs,
+                    self_closing,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXOpeningFragment {
-    #[doc = "Calls [VisitAll`::visit_jsx_opening_fragment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_opening_fragment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXOpeningFragment {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_opening_fragment`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_opening_fragment(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXOpeningFragment { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXOpeningFragment(
+                        self::fields::JSXOpeningFragmentField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXOpeningFragment { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXSpreadChild {
-    #[doc = "Calls [VisitAll`::visit_jsx_spread_child`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_spread_child(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXSpreadChild {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_spread_child`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_spread_child(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXSpreadChild { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
+                        self::fields::JSXSpreadChildField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::JSXSpreadChild(
+                        self::fields::JSXSpreadChildField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXSpreadChild { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for JSXText {
-    #[doc = "Calls [VisitAll`::visit_jsx_text`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_text(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for JSXText {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_text`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_text(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             JSXText { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::JSXText(self::fields::JSXTextField::Raw));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                JSXText { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Key {
-    #[doc = "Calls [VisitAll`::visit_key`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_key(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Key {
+    #[doc = "Calls [FoldAstPath`::fold_key`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_key(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Key::Private { 0: _field_0 } => {
-                <PrivateName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Private));
+                let _field_0 = <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Key::Private { 0: _field_0 }
             }
             Key::Public { 0: _field_0 } => {
-                <PropName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Key(self::fields::KeyField::Public));
+                let _field_0 = <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Key::Public { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for KeyValuePatProp {
-    #[doc = "Calls [VisitAll`::visit_key_value_pat_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_key_value_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyValuePatProp {
+    #[doc = "Calls [FoldAstPath`::fold_key_value_pat_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_key_value_pat_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             KeyValuePatProp { key, value } => {
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
+                        self::fields::KeyValuePatPropField::Key,
+                    ));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Pat> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValuePatProp(
+                        self::fields::KeyValuePatPropField::Value,
+                    ));
+                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                KeyValuePatProp { key, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for KeyValueProp {
-    #[doc = "Calls [VisitAll`::visit_key_value_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_key_value_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for KeyValueProp {
+    #[doc = "Calls [FoldAstPath`::fold_key_value_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_key_value_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             KeyValueProp { key, value } => {
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
+                        self::fields::KeyValuePropField::Key,
+                    ));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::KeyValueProp(
+                        self::fields::KeyValuePropField::Value,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                KeyValueProp { key, value }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for LabeledStmt {
-    #[doc = "Calls [VisitAll`::visit_labeled_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_labeled_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for LabeledStmt {
+    #[doc = "Calls [FoldAstPath`::fold_labeled_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_labeled_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             LabeledStmt { span, label, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
+                        self::fields::LabeledStmtField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(label, visitor)
+                let label = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
+                        self::fields::LabeledStmtField::Label,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::LabeledStmt(
+                        self::fields::LabeledStmtField::Body,
+                    ));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                LabeledStmt { span, label, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Lit {
-    #[doc = "Calls [VisitAll`::visit_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Lit {
+    #[doc = "Calls [FoldAstPath`::fold_lit`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_lit(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Lit::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Str));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Lit::Str { 0: _field_0 }
             }
             Lit::Bool { 0: _field_0 } => {
-                <Bool as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Bool));
+                let _field_0 = <Bool as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Lit::Bool { 0: _field_0 }
             }
             Lit::Null { 0: _field_0 } => {
-                <Null as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Null));
+                let _field_0 = <Null as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Lit::Null { 0: _field_0 }
             }
             Lit::Num { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Num));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Lit::Num { 0: _field_0 }
             }
             Lit::BigInt { 0: _field_0 } => {
-                <BigInt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::BigInt));
+                let _field_0 = <BigInt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Lit::BigInt { 0: _field_0 }
             }
             Lit::Regex { 0: _field_0 } => {
-                <Regex as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Regex));
+                let _field_0 = <Regex as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Lit::Regex { 0: _field_0 }
             }
             Lit::JSXText { 0: _field_0 } => {
-                <JSXText as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Lit(self::fields::LitField::Jsxtext));
+                let _field_0 = <JSXText as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Lit::JSXText { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MemberExpr {
-    #[doc = "Calls [VisitAll`::visit_member_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_member_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MemberExpr {
+    #[doc = "Calls [FoldAstPath`::fold_member_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_member_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MemberExpr { span, obj, prop } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
+                        self::fields::MemberExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(obj, visitor)
+                let obj = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
+                        self::fields::MemberExprField::Obj,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MemberProp as VisitAllWith<V>>::visit_with(prop, visitor)
+                let prop = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberExpr(
+                        self::fields::MemberExprField::Prop,
+                    ));
+                    <MemberProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MemberExpr { span, obj, prop }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MemberProp {
-    #[doc = "Calls [VisitAll`::visit_member_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_member_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MemberProp {
+    #[doc = "Calls [FoldAstPath`::fold_member_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_member_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MemberProp::Ident { 0: _field_0 } => {
-                <IdentName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
+                    self::fields::MemberPropField::Ident,
+                ));
+                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MemberProp::Ident { 0: _field_0 }
             }
             MemberProp::PrivateName { 0: _field_0 } => {
-                <PrivateName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
+                    self::fields::MemberPropField::PrivateName,
+                ));
+                let _field_0 = <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MemberProp::PrivateName { 0: _field_0 }
             }
             MemberProp::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::MemberProp(
+                    self::fields::MemberPropField::Computed,
+                ));
+                let _field_0 = <ComputedPropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                MemberProp::Computed { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MetaPropExpr {
-    #[doc = "Calls [VisitAll`::visit_meta_prop_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_meta_prop_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MetaPropExpr {
+    #[doc = "Calls [FoldAstPath`::fold_meta_prop_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_meta_prop_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MetaPropExpr { span, kind } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
+                        self::fields::MetaPropExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MetaPropKind as VisitAllWith<V>>::visit_with(kind, visitor)
+                let kind = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MetaPropExpr(
+                        self::fields::MetaPropExprField::Kind,
+                    ));
+                    <MetaPropKind as FoldWithAstPath<V>>::fold_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MetaPropExpr { span, kind }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MetaPropKind {
-    #[doc = "Calls [VisitAll`::visit_meta_prop_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_meta_prop_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MetaPropKind {
+    #[doc = "Calls [FoldAstPath`::fold_meta_prop_kind`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_meta_prop_kind(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            MetaPropKind::NewTarget => {}
-            MetaPropKind::ImportMeta => {}
+            MetaPropKind::NewTarget => MetaPropKind::NewTarget,
+            MetaPropKind::ImportMeta => MetaPropKind::ImportMeta,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MethodKind {
-    #[doc = "Calls [VisitAll`::visit_method_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_method_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MethodKind {
+    #[doc = "Calls [FoldAstPath`::fold_method_kind`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_method_kind(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            MethodKind::Method => {}
-            MethodKind::Getter => {}
-            MethodKind::Setter => {}
+            MethodKind::Method => MethodKind::Method,
+            MethodKind::Getter => MethodKind::Getter,
+            MethodKind::Setter => MethodKind::Setter,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for MethodProp {
-    #[doc = "Calls [VisitAll`::visit_method_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_method_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for MethodProp {
+    #[doc = "Calls [FoldAstPath`::fold_method_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_method_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             MethodProp { key, function } => {
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
+                        self::fields::MethodPropField::Key,
+                    ));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Function> as VisitAllWith<V>>::visit_with(function, visitor)
+                let function = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::MethodProp(
+                        self::fields::MethodPropField::Function,
+                    ));
+                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                MethodProp { key, function }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Module {
-    #[doc = "Calls [VisitAll`::visit_module`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_module(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Module {
+    #[doc = "Calls [FoldAstPath`::fold_module`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_module(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Module {
                 span,
                 body,
                 shebang,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ModuleItem> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Module(
+                        self::fields::ModuleField::Body(usize::MAX),
+                    ));
+                    <Vec<ModuleItem> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(shebang, visitor)
+                let shebang = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Module(self::fields::ModuleField::Shebang));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        shebang,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Module {
+                    span,
+                    body,
+                    shebang,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ModuleDecl {
-    #[doc = "Calls [VisitAll`::visit_module_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_module_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ModuleDecl {
+    #[doc = "Calls [FoldAstPath`::fold_module_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_module_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ModuleDecl::Import { 0: _field_0 } => {
-                <ImportDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::Import,
+                ));
+                let _field_0 = <ImportDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::Import { 0: _field_0 }
             }
             ModuleDecl::ExportDecl { 0: _field_0 } => {
-                <ExportDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportDecl,
+                ));
+                let _field_0 = <ExportDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::ExportDecl { 0: _field_0 }
             }
             ModuleDecl::ExportNamed { 0: _field_0 } => {
-                <NamedExport as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportNamed,
+                ));
+                let _field_0 = <NamedExport as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::ExportNamed { 0: _field_0 }
             }
             ModuleDecl::ExportDefaultDecl { 0: _field_0 } => {
-                <ExportDefaultDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportDefaultDecl,
+                ));
+                let _field_0 = <ExportDefaultDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::ExportDefaultDecl { 0: _field_0 }
             }
             ModuleDecl::ExportDefaultExpr { 0: _field_0 } => {
-                <ExportDefaultExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportDefaultExpr,
+                ));
+                let _field_0 = <ExportDefaultExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::ExportDefaultExpr { 0: _field_0 }
             }
             ModuleDecl::ExportAll { 0: _field_0 } => {
-                <ExportAll as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::ExportAll,
+                ));
+                let _field_0 = <ExportAll as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::ExportAll { 0: _field_0 }
             }
             ModuleDecl::TsImportEquals { 0: _field_0 } => {
-                <Box<TsImportEqualsDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::TsImportEquals,
+                ));
+                let _field_0 = <Box<TsImportEqualsDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::TsImportEquals { 0: _field_0 }
             }
             ModuleDecl::TsExportAssignment { 0: _field_0 } => {
-                <TsExportAssignment as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::TsExportAssignment,
+                ));
+                let _field_0 = <TsExportAssignment as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::TsExportAssignment { 0: _field_0 }
             }
             ModuleDecl::TsNamespaceExport { 0: _field_0 } => {
-                <TsNamespaceExportDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleDecl(
+                    self::fields::ModuleDeclField::TsNamespaceExport,
+                ));
+                let _field_0 = <TsNamespaceExportDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleDecl::TsNamespaceExport { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ModuleExportName {
-    #[doc = "Calls [VisitAll`::visit_module_export_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_module_export_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ModuleExportName {
+    #[doc = "Calls [FoldAstPath`::fold_module_export_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_module_export_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ModuleExportName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
+                    self::fields::ModuleExportNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleExportName::Ident { 0: _field_0 }
             }
             ModuleExportName::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleExportName(
+                    self::fields::ModuleExportNameField::Str,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleExportName::Str { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ModuleItem {
-    #[doc = "Calls [VisitAll`::visit_module_item`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_module_item(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ModuleItem {
+    #[doc = "Calls [FoldAstPath`::fold_module_item`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_module_item(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ModuleItem::ModuleDecl { 0: _field_0 } => {
-                <ModuleDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
+                    self::fields::ModuleItemField::ModuleDecl,
+                ));
+                let _field_0 = <ModuleDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleItem::ModuleDecl { 0: _field_0 }
             }
             ModuleItem::Stmt { 0: _field_0 } => {
-                <Stmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ModuleItem(
+                    self::fields::ModuleItemField::Stmt,
+                ));
+                let _field_0 = <Stmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ModuleItem::Stmt { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NamedExport {
-    #[doc = "Calls [VisitAll`::visit_named_export`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_named_export(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NamedExport {
+    #[doc = "Calls [FoldAstPath`::fold_named_export`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_named_export(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             NamedExport {
                 span,
@@ -150251,29 +128401,66 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for NamedExport {
                 type_only,
                 with,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ExportSpecifier> as VisitAllWith<V>>::visit_with(specifiers, visitor)
+                let specifiers = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::Specifiers(usize::MAX),
+                    ));
+                    <Vec<ExportSpecifier> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        specifiers,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Str>> as VisitAllWith<V>>::visit_with(src, visitor)
+                let src = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::Src,
+                    ));
+                    <Option<Box<Str>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        src,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<ObjectLit>> as VisitAllWith<V>>::visit_with(with, visitor)
+                let with = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NamedExport(
+                        self::fields::NamedExportField::With,
+                    ));
+                    <Option<Box<ObjectLit>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        with,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                NamedExport {
+                    span,
+                    specifiers,
+                    src,
+                    type_only,
+                    with,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for NewExpr {
-    #[doc = "Calls [VisitAll`::visit_new_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_new_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for NewExpr {
+    #[doc = "Calls [FoldAstPath`::fold_new_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_new_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             NewExpr {
                 span,
@@ -150282,88 +128469,162 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for NewExpr {
                 args,
                 type_args,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(callee, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Vec<ExprOrSpread>> as VisitAllWith<V>>::visit_with(args, visitor)
+                let callee = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::Callee));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::NewExpr(
+                        self::fields::NewExprField::Args(usize::MAX),
+                    ));
+                    <Option<Vec<ExprOrSpread>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_args = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::NewExpr(self::fields::NewExprField::TypeArgs));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
+                NewExpr {
+                    span,
+                    ctxt,
+                    callee,
+                    args,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Null {
-    #[doc = "Calls [VisitAll`::visit_null`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_null(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Null {
+    #[doc = "Calls [FoldAstPath`::fold_null`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_null(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Null { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Null(self::fields::NullField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Null { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Number {
-    #[doc = "Calls [VisitAll`::visit_number`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_number(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Number {
+    #[doc = "Calls [FoldAstPath`::fold_number`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_number(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Number { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Number(self::fields::NumberField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Number { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ObjectLit {
-    #[doc = "Calls [VisitAll`::visit_object_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_object_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectLit {
+    #[doc = "Calls [FoldAstPath`::fold_object_lit`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_object_lit(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ObjectLit { span, props } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ObjectLit(self::fields::ObjectLitField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<PropOrSpread> as VisitAllWith<V>>::visit_with(props, visitor)
+                let props = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectLit(
+                        self::fields::ObjectLitField::Props(usize::MAX),
+                    ));
+                    <Vec<PropOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        props,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ObjectLit { span, props }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ObjectPat {
-    #[doc = "Calls [VisitAll`::visit_object_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_object_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectPat {
+    #[doc = "Calls [FoldAstPath`::fold_object_pat`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_object_pat(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ObjectPat {
                 span,
@@ -150371,46 +128632,100 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for ObjectPat {
                 optional,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ObjectPat(self::fields::ObjectPatField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ObjectPatProp> as VisitAllWith<V>>::visit_with(props, visitor)
+                let props = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
+                        self::fields::ObjectPatField::Props(usize::MAX),
+                    ));
+                    <Vec<ObjectPatProp> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        props,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPat(
+                        self::fields::ObjectPatField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ObjectPat {
+                    span,
+                    props,
+                    optional,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ObjectPatProp {
-    #[doc = "Calls [VisitAll`::visit_object_pat_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_object_pat_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ObjectPatProp {
+    #[doc = "Calls [FoldAstPath`::fold_object_pat_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_object_pat_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ObjectPatProp::KeyValue { 0: _field_0 } => {
-                <KeyValuePatProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
+                    self::fields::ObjectPatPropField::KeyValue,
+                ));
+                let _field_0 = <KeyValuePatProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ObjectPatProp::KeyValue { 0: _field_0 }
             }
             ObjectPatProp::Assign { 0: _field_0 } => {
-                <AssignPatProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
+                    self::fields::ObjectPatPropField::Assign,
+                ));
+                let _field_0 = <AssignPatProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ObjectPatProp::Assign { 0: _field_0 }
             }
             ObjectPatProp::Rest { 0: _field_0 } => {
-                <RestPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ObjectPatProp(
+                    self::fields::ObjectPatPropField::Rest,
+                ));
+                let _field_0 = <RestPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ObjectPatProp::Rest { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for OptCall {
-    #[doc = "Calls [VisitAll`::visit_opt_call`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_call(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptCall {
+    #[doc = "Calls [FoldAstPath`::fold_opt_call`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_call(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             OptCall {
                 span,
@@ -150419,168 +128734,347 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for OptCall {
                 args,
                 type_args,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(callee, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ExprOrSpread> as VisitAllWith<V>>::visit_with(args, visitor)
+                let callee = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::Callee));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        callee,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptCall(
+                        self::fields::OptCallField::Args(usize::MAX),
+                    ));
+                    <Vec<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        args,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_args = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::OptCall(self::fields::OptCallField::TypeArgs));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
+                OptCall {
+                    span,
+                    ctxt,
+                    callee,
+                    args,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for OptChainBase {
-    #[doc = "Calls [VisitAll`::visit_opt_chain_base`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_chain_base(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptChainBase {
+    #[doc = "Calls [FoldAstPath`::fold_opt_chain_base`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_chain_base(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             OptChainBase::Member { 0: _field_0 } => {
-                <MemberExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
+                    self::fields::OptChainBaseField::Member,
+                ));
+                let _field_0 = <MemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                OptChainBase::Member { 0: _field_0 }
             }
             OptChainBase::Call { 0: _field_0 } => {
-                <OptCall as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainBase(
+                    self::fields::OptChainBaseField::Call,
+                ));
+                let _field_0 = <OptCall as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                OptChainBase::Call { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for OptChainExpr {
-    #[doc = "Calls [VisitAll`::visit_opt_chain_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_chain_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for OptChainExpr {
+    #[doc = "Calls [FoldAstPath`::fold_opt_chain_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_chain_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             OptChainExpr {
                 span,
                 optional,
                 base,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
+                        self::fields::OptChainExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<OptChainBase> as VisitAllWith<V>>::visit_with(base, visitor)
+                let base = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::OptChainExpr(
+                        self::fields::OptChainExprField::Base,
+                    ));
+                    <Box<OptChainBase> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        base,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                OptChainExpr {
+                    span,
+                    optional,
+                    base,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Param {
-    #[doc = "Calls [VisitAll`::visit_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Param {
+    #[doc = "Calls [FoldAstPath`::fold_param`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_param(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Param {
                 span,
                 decorators,
                 pat,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Decorator> as VisitAllWith<V>>::visit_with(decorators, visitor)
+                let decorators = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Param(
+                        self::fields::ParamField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Pat as VisitAllWith<V>>::visit_with(pat, visitor)
+                let pat = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Param(self::fields::ParamField::Pat));
+                    <Pat as FoldWithAstPath<V>>::fold_with_ast_path(pat, visitor, &mut *__ast_path)
                 };
+                Param {
+                    span,
+                    decorators,
+                    pat,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ParamOrTsParamProp {
-    #[doc = "Calls [VisitAll`::visit_param_or_ts_param_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_param_or_ts_param_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ParamOrTsParamProp {
+    #[doc = "Calls [FoldAstPath`::fold_param_or_ts_param_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_param_or_ts_param_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ParamOrTsParamProp::TsParamProp { 0: _field_0 } => {
-                <TsParamProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
+                    self::fields::ParamOrTsParamPropField::TsParamProp,
+                ));
+                let _field_0 = <TsParamProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ParamOrTsParamProp::TsParamProp { 0: _field_0 }
             }
             ParamOrTsParamProp::Param { 0: _field_0 } => {
-                <Param as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::ParamOrTsParamProp(
+                    self::fields::ParamOrTsParamPropField::Param,
+                ));
+                let _field_0 = <Param as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                ParamOrTsParamProp::Param { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ParenExpr {
-    #[doc = "Calls [VisitAll`::visit_paren_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_paren_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ParenExpr {
+    #[doc = "Calls [FoldAstPath`::fold_paren_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_paren_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ParenExpr { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ParenExpr(self::fields::ParenExprField::Expr));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ParenExpr { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Pat {
-    #[doc = "Calls [VisitAll`::visit_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Pat {
+    #[doc = "Calls [FoldAstPath`::fold_pat`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pat(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Pat::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Ident));
+                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Pat::Ident { 0: _field_0 }
             }
             Pat::Array { 0: _field_0 } => {
-                <ArrayPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Array));
+                let _field_0 = <ArrayPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Pat::Array { 0: _field_0 }
             }
             Pat::Rest { 0: _field_0 } => {
-                <RestPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Rest));
+                let _field_0 = <RestPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Pat::Rest { 0: _field_0 }
             }
             Pat::Object { 0: _field_0 } => {
-                <ObjectPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Object));
+                let _field_0 = <ObjectPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Pat::Object { 0: _field_0 }
             }
             Pat::Assign { 0: _field_0 } => {
-                <AssignPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Assign));
+                let _field_0 = <AssignPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Pat::Assign { 0: _field_0 }
             }
             Pat::Invalid { 0: _field_0 } => {
-                <Invalid as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Invalid));
+                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Pat::Invalid { 0: _field_0 }
             }
             Pat::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Pat(self::fields::PatField::Expr));
+                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Pat::Expr { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PrivateMethod {
-    #[doc = "Calls [VisitAll`::visit_private_method`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_private_method(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateMethod {
+    #[doc = "Calls [FoldAstPath`::fold_private_method`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_private_method(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PrivateMethod {
                 span,
@@ -150593,51 +129087,116 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for PrivateMethod {
                 is_optional,
                 is_override,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <PrivateName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Key,
+                    ));
+                    <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Function> as VisitAllWith<V>>::visit_with(function, visitor)
+                let function = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Function,
+                    ));
+                    <Box<Function> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        function,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <MethodKind as VisitAllWith<V>>::visit_with(kind, visitor)
+                let kind = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Kind,
+                    ));
+                    <MethodKind as FoldWithAstPath<V>>::fold_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Accessibility> as VisitAllWith<V>>::visit_with(accessibility, visitor)
+                let accessibility = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateMethod(
+                        self::fields::PrivateMethodField::Accessibility,
+                    ));
+                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                PrivateMethod {
+                    span,
+                    key,
+                    function,
+                    kind,
+                    is_static,
+                    accessibility,
+                    is_abstract,
+                    is_optional,
+                    is_override,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PrivateName {
-    #[doc = "Calls [VisitAll`::visit_private_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_private_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateName {
+    #[doc = "Calls [FoldAstPath`::fold_private_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_private_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PrivateName { span, name } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
+                        self::fields::PrivateNameField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateName(
+                        self::fields::PrivateNameField::Name,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                PrivateName { span, name }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PrivateProp {
-    #[doc = "Calls [VisitAll`::visit_private_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_private_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PrivateProp {
+    #[doc = "Calls [FoldAstPath`::fold_private_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_private_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PrivateProp {
                 span,
@@ -150653,149 +129212,351 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for PrivateProp {
                 readonly,
                 definite,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Ctxt,
+                    ));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <PrivateName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Key,
+                    ));
+                    <PrivateName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Value,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Decorator> as VisitAllWith<V>>::visit_with(decorators, visitor)
+                let decorators = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Accessibility> as VisitAllWith<V>>::visit_with(accessibility, visitor)
+                let accessibility = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::PrivateProp(
+                        self::fields::PrivatePropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                PrivateProp {
+                    span,
+                    ctxt,
+                    key,
+                    value,
+                    type_ann,
+                    is_static,
+                    decorators,
+                    accessibility,
+                    is_optional,
+                    is_override,
+                    readonly,
+                    definite,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Program {
-    #[doc = "Calls [VisitAll`::visit_program`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_program(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Program {
+    #[doc = "Calls [FoldAstPath`::fold_program`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_program(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Program::Module { 0: _field_0 } => {
-                <Module as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Module));
+                let _field_0 = <Module as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Program::Module { 0: _field_0 }
             }
             Program::Script { 0: _field_0 } => {
-                <Script as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::Program(self::fields::ProgramField::Script));
+                let _field_0 = <Script as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Program::Script { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Prop {
-    #[doc = "Calls [VisitAll`::visit_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Prop {
+    #[doc = "Calls [FoldAstPath`::fold_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Prop::Shorthand { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Shorthand));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Prop::Shorthand { 0: _field_0 }
             }
             Prop::KeyValue { 0: _field_0 } => {
-                <KeyValueProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::KeyValue));
+                let _field_0 = <KeyValueProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Prop::KeyValue { 0: _field_0 }
             }
             Prop::Assign { 0: _field_0 } => {
-                <AssignProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Assign));
+                let _field_0 = <AssignProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Prop::Assign { 0: _field_0 }
             }
             Prop::Getter { 0: _field_0 } => {
-                <GetterProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Getter));
+                let _field_0 = <GetterProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Prop::Getter { 0: _field_0 }
             }
             Prop::Setter { 0: _field_0 } => {
-                <SetterProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Setter));
+                let _field_0 = <SetterProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Prop::Setter { 0: _field_0 }
             }
             Prop::Method { 0: _field_0 } => {
-                <MethodProp as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Prop(self::fields::PropField::Method));
+                let _field_0 = <MethodProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Prop::Method { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PropName {
-    #[doc = "Calls [VisitAll`::visit_prop_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_prop_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PropName {
+    #[doc = "Calls [FoldAstPath`::fold_prop_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_prop_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PropName::Ident { 0: _field_0 } => {
-                <IdentName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Ident));
+                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PropName::Ident { 0: _field_0 }
             }
             PropName::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Str));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PropName::Str { 0: _field_0 }
             }
             PropName::Num { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::Num));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PropName::Num { 0: _field_0 }
             }
             PropName::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropName(
+                    self::fields::PropNameField::Computed,
+                ));
+                let _field_0 = <ComputedPropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PropName::Computed { 0: _field_0 }
             }
             PropName::BigInt { 0: _field_0 } => {
-                <BigInt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::PropName(self::fields::PropNameField::BigInt));
+                let _field_0 = <BigInt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PropName::BigInt { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for PropOrSpread {
-    #[doc = "Calls [VisitAll`::visit_prop_or_spread`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_prop_or_spread(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for PropOrSpread {
+    #[doc = "Calls [FoldAstPath`::fold_prop_or_spread`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_prop_or_spread(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             PropOrSpread::Spread { 0: _field_0 } => {
-                <SpreadElement as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
+                    self::fields::PropOrSpreadField::Spread,
+                ));
+                let _field_0 = <SpreadElement as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PropOrSpread::Spread { 0: _field_0 }
             }
             PropOrSpread::Prop { 0: _field_0 } => {
-                <Box<Prop> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::PropOrSpread(
+                    self::fields::PropOrSpreadField::Prop,
+                ));
+                let _field_0 = <Box<Prop> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                PropOrSpread::Prop { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Regex {
-    #[doc = "Calls [VisitAll`::visit_regex`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_regex(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Regex {
+    #[doc = "Calls [FoldAstPath`::fold_regex`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_regex(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Regex { span, exp, flags } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(exp, visitor)
+                let exp = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Regex(self::fields::RegexField::Exp));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        exp,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(flags, visitor)
+                let flags = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Regex(self::fields::RegexField::Flags));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        flags,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Regex { span, exp, flags }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for RestPat {
-    #[doc = "Calls [VisitAll`::visit_rest_pat`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_rest_pat(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for RestPat {
+    #[doc = "Calls [FoldAstPath`::fold_rest_pat`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_rest_pat(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             RestPat {
                 span,
@@ -150803,93 +129564,185 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for RestPat {
                 arg,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(dot3_token, visitor)
+                let dot3_token = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::RestPat(
+                        self::fields::RestPatField::Dot3Token,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        dot3_token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Pat> as VisitAllWith<V>>::visit_with(arg, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::Arg));
+                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::RestPat(self::fields::RestPatField::TypeAnn));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                RestPat {
+                    span,
+                    dot3_token,
+                    arg,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ReturnStmt {
-    #[doc = "Calls [VisitAll`::visit_return_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_return_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ReturnStmt {
+    #[doc = "Calls [FoldAstPath`::fold_return_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_return_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ReturnStmt { span, arg } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
+                        self::fields::ReturnStmtField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(arg, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::ReturnStmt(
+                        self::fields::ReturnStmtField::Arg,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ReturnStmt { span, arg }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Script {
-    #[doc = "Calls [VisitAll`::visit_script`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_script(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Script {
+    #[doc = "Calls [FoldAstPath`::fold_script`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_script(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Script {
                 span,
                 body,
                 shebang,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Script(
+                        self::fields::ScriptField::Body(usize::MAX),
+                    ));
+                    <Vec<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(shebang, visitor)
+                let shebang = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::Script(self::fields::ScriptField::Shebang));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        shebang,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Script {
+                    span,
+                    body,
+                    shebang,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SeqExpr {
-    #[doc = "Calls [VisitAll`::visit_seq_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_seq_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SeqExpr {
+    #[doc = "Calls [FoldAstPath`::fold_seq_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_seq_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SeqExpr { span, exprs } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::SeqExpr(self::fields::SeqExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Box<Expr>> as VisitAllWith<V>>::visit_with(exprs, visitor)
+                let exprs = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SeqExpr(
+                        self::fields::SeqExprField::Exprs(usize::MAX),
+                    ));
+                    <Vec<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        exprs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SeqExpr { span, exprs }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SetterProp {
-    #[doc = "Calls [VisitAll`::visit_setter_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_setter_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SetterProp {
+    #[doc = "Calls [FoldAstPath`::fold_setter_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_setter_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SetterProp {
                 span,
@@ -150898,307 +129751,734 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for SetterProp {
                 param,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <PropName as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Key,
+                    ));
+                    <PropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Pat> as VisitAllWith<V>>::visit_with(this_param, visitor)
+                let this_param = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::ThisParam,
+                    ));
+                    <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        this_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Pat> as VisitAllWith<V>>::visit_with(param, visitor)
+                let param = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Param,
+                    ));
+                    <Box<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<BlockStmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SetterProp(
+                        self::fields::SetterPropField::Body,
+                    ));
+                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SetterProp {
+                    span,
+                    key,
+                    this_param,
+                    param,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SimpleAssignTarget {
-    #[doc = "Calls [VisitAll`::visit_simple_assign_target`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_simple_assign_target(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SimpleAssignTarget {
+    #[doc = "Calls [FoldAstPath`::fold_simple_assign_target`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_simple_assign_target(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SimpleAssignTarget::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Ident,
+                ));
+                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::Ident { 0: _field_0 }
             }
             SimpleAssignTarget::Member { 0: _field_0 } => {
-                <MemberExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Member,
+                ));
+                let _field_0 = <MemberExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::Member { 0: _field_0 }
             }
             SimpleAssignTarget::SuperProp { 0: _field_0 } => {
-                <SuperPropExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::SuperProp,
+                ));
+                let _field_0 = <SuperPropExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::SuperProp { 0: _field_0 }
             }
             SimpleAssignTarget::Paren { 0: _field_0 } => {
-                <ParenExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Paren,
+                ));
+                let _field_0 = <ParenExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::Paren { 0: _field_0 }
             }
             SimpleAssignTarget::OptChain { 0: _field_0 } => {
-                <OptChainExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::OptChain,
+                ));
+                let _field_0 = <OptChainExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::OptChain { 0: _field_0 }
             }
             SimpleAssignTarget::TsAs { 0: _field_0 } => {
-                <TsAsExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsAs,
+                ));
+                let _field_0 = <TsAsExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::TsAs { 0: _field_0 }
             }
             SimpleAssignTarget::TsSatisfies { 0: _field_0 } => {
-                <TsSatisfiesExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsSatisfies,
+                ));
+                let _field_0 = <TsSatisfiesExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::TsSatisfies { 0: _field_0 }
             }
             SimpleAssignTarget::TsNonNull { 0: _field_0 } => {
-                <TsNonNullExpr as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsNonNull,
+                ));
+                let _field_0 = <TsNonNullExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::TsNonNull { 0: _field_0 }
             }
             SimpleAssignTarget::TsTypeAssertion { 0: _field_0 } => {
-                <TsTypeAssertion as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsTypeAssertion,
+                ));
+                let _field_0 = <TsTypeAssertion as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::TsTypeAssertion { 0: _field_0 }
             }
             SimpleAssignTarget::TsInstantiation { 0: _field_0 } => {
-                <TsInstantiation as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::TsInstantiation,
+                ));
+                let _field_0 = <TsInstantiation as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::TsInstantiation { 0: _field_0 }
             }
             SimpleAssignTarget::Invalid { 0: _field_0 } => {
-                <Invalid as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SimpleAssignTarget(
+                    self::fields::SimpleAssignTargetField::Invalid,
+                ));
+                let _field_0 = <Invalid as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SimpleAssignTarget::Invalid { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SpreadElement {
-    #[doc = "Calls [VisitAll`::visit_spread_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_spread_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SpreadElement {
+    #[doc = "Calls [FoldAstPath`::fold_spread_element`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_spread_element(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SpreadElement { dot3_token, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(dot3_token, visitor)
+                let dot3_token = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
+                        self::fields::SpreadElementField::Dot3Token,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        dot3_token,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SpreadElement(
+                        self::fields::SpreadElementField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SpreadElement { dot3_token, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for StaticBlock {
-    #[doc = "Calls [VisitAll`::visit_static_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_static_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for StaticBlock {
+    #[doc = "Calls [FoldAstPath`::fold_static_block`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_static_block(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             StaticBlock { span, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
+                        self::fields::StaticBlockField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <BlockStmt as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::StaticBlock(
+                        self::fields::StaticBlockField::Body,
+                    ));
+                    <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                StaticBlock { span, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Stmt {
-    #[doc = "Calls [VisitAll`::visit_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Stmt {
+    #[doc = "Calls [FoldAstPath`::fold_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Stmt::Block { 0: _field_0 } => {
-                <BlockStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Block));
+                let _field_0 = <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Block { 0: _field_0 }
             }
             Stmt::Empty { 0: _field_0 } => {
-                <EmptyStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Empty));
+                let _field_0 = <EmptyStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Empty { 0: _field_0 }
             }
             Stmt::Debugger { 0: _field_0 } => {
-                <DebuggerStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Debugger));
+                let _field_0 = <DebuggerStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Debugger { 0: _field_0 }
             }
             Stmt::With { 0: _field_0 } => {
-                <WithStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::With));
+                let _field_0 = <WithStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::With { 0: _field_0 }
             }
             Stmt::Return { 0: _field_0 } => {
-                <ReturnStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Return));
+                let _field_0 = <ReturnStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Return { 0: _field_0 }
             }
             Stmt::Labeled { 0: _field_0 } => {
-                <LabeledStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Labeled));
+                let _field_0 = <LabeledStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Labeled { 0: _field_0 }
             }
             Stmt::Break { 0: _field_0 } => {
-                <BreakStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Break));
+                let _field_0 = <BreakStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Break { 0: _field_0 }
             }
             Stmt::Continue { 0: _field_0 } => {
-                <ContinueStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Continue));
+                let _field_0 = <ContinueStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Continue { 0: _field_0 }
             }
             Stmt::If { 0: _field_0 } => {
-                <IfStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::If));
+                let _field_0 = <IfStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::If { 0: _field_0 }
             }
             Stmt::Switch { 0: _field_0 } => {
-                <SwitchStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Switch));
+                let _field_0 = <SwitchStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Switch { 0: _field_0 }
             }
             Stmt::Throw { 0: _field_0 } => {
-                <ThrowStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Throw));
+                let _field_0 = <ThrowStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Throw { 0: _field_0 }
             }
             Stmt::Try { 0: _field_0 } => {
-                <Box<TryStmt> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Try));
+                let _field_0 = <Box<TryStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Try { 0: _field_0 }
             }
             Stmt::While { 0: _field_0 } => {
-                <WhileStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::While));
+                let _field_0 = <WhileStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::While { 0: _field_0 }
             }
             Stmt::DoWhile { 0: _field_0 } => {
-                <DoWhileStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::DoWhile));
+                let _field_0 = <DoWhileStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::DoWhile { 0: _field_0 }
             }
             Stmt::For { 0: _field_0 } => {
-                <ForStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::For));
+                let _field_0 = <ForStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::For { 0: _field_0 }
             }
             Stmt::ForIn { 0: _field_0 } => {
-                <ForInStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForIn));
+                let _field_0 = <ForInStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::ForIn { 0: _field_0 }
             }
             Stmt::ForOf { 0: _field_0 } => {
-                <ForOfStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::ForOf));
+                let _field_0 = <ForOfStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::ForOf { 0: _field_0 }
             }
             Stmt::Decl { 0: _field_0 } => {
-                <Decl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Decl));
+                let _field_0 = <Decl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Decl { 0: _field_0 }
             }
             Stmt::Expr { 0: _field_0 } => {
-                <ExprStmt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::Stmt(self::fields::StmtField::Expr));
+                let _field_0 = <ExprStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                Stmt::Expr { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Str {
-    #[doc = "Calls [VisitAll`::visit_str`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_str(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Str {
+    #[doc = "Calls [FoldAstPath`::fold_str`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_str(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Str { span, value, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(value, visitor)
+                let value = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Value));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        value,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Str(self::fields::StrField::Raw));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Str { span, value, raw }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Super {
-    #[doc = "Calls [VisitAll`::visit_super`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_super(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Super {
+    #[doc = "Calls [FoldAstPath`::fold_super`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_super(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Super { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Super(self::fields::SuperField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Super { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SuperProp {
-    #[doc = "Calls [VisitAll`::visit_super_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_super_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SuperProp {
+    #[doc = "Calls [FoldAstPath`::fold_super_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_super_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SuperProp::Ident { 0: _field_0 } => {
-                <IdentName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
+                    self::fields::SuperPropField::Ident,
+                ));
+                let _field_0 = <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SuperProp::Ident { 0: _field_0 }
             }
             SuperProp::Computed { 0: _field_0 } => {
-                <ComputedPropName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperProp(
+                    self::fields::SuperPropField::Computed,
+                ));
+                let _field_0 = <ComputedPropName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                SuperProp::Computed { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SuperPropExpr {
-    #[doc = "Calls [VisitAll`::visit_super_prop_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_super_prop_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SuperPropExpr {
+    #[doc = "Calls [FoldAstPath`::fold_super_prop_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_super_prop_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SuperPropExpr { span, obj, prop } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
+                        self::fields::SuperPropExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Super as VisitAllWith<V>>::visit_with(obj, visitor)
+                let obj = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
+                        self::fields::SuperPropExprField::Obj,
+                    ));
+                    <Super as FoldWithAstPath<V>>::fold_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <SuperProp as VisitAllWith<V>>::visit_with(prop, visitor)
+                let prop = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SuperPropExpr(
+                        self::fields::SuperPropExprField::Prop,
+                    ));
+                    <SuperProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                        prop,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SuperPropExpr { span, obj, prop }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SwitchCase {
-    #[doc = "Calls [VisitAll`::visit_switch_case`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_switch_case(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SwitchCase {
+    #[doc = "Calls [FoldAstPath`::fold_switch_case`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_switch_case(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SwitchCase { span, test, cons } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
+                        self::fields::SwitchCaseField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(test, visitor)
+                let test = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
+                        self::fields::SwitchCaseField::Test,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Stmt> as VisitAllWith<V>>::visit_with(cons, visitor)
+                let cons = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchCase(
+                        self::fields::SwitchCaseField::Cons(usize::MAX),
+                    ));
+                    <Vec<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        cons,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SwitchCase { span, test, cons }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for SwitchStmt {
-    #[doc = "Calls [VisitAll`::visit_switch_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_switch_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for SwitchStmt {
+    #[doc = "Calls [FoldAstPath`::fold_switch_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_switch_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             SwitchStmt {
                 span,
                 discriminant,
                 cases,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
+                        self::fields::SwitchStmtField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(discriminant, visitor)
+                let discriminant = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
+                        self::fields::SwitchStmtField::Discriminant,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        discriminant,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<SwitchCase> as VisitAllWith<V>>::visit_with(cases, visitor)
+                let cases = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::SwitchStmt(
+                        self::fields::SwitchStmtField::Cases(usize::MAX),
+                    ));
+                    <Vec<SwitchCase> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        cases,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                SwitchStmt {
+                    span,
+                    discriminant,
+                    cases,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TaggedTpl {
-    #[doc = "Calls [VisitAll`::visit_tagged_tpl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_tagged_tpl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TaggedTpl {
+    #[doc = "Calls [FoldAstPath`::fold_tagged_tpl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_tagged_tpl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TaggedTpl {
                 span,
@@ -151207,96 +130487,180 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TaggedTpl {
                 type_params,
                 tpl,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(tag, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_params,
+                let tag = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tag));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        tag,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Box<Tpl> as VisitAllWith<V>>::visit_with(tpl, visitor)
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TaggedTpl(
+                        self::fields::TaggedTplField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                let tpl = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TaggedTpl(self::fields::TaggedTplField::Tpl));
+                    <Box<Tpl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        tpl,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TaggedTpl {
+                    span,
+                    ctxt,
+                    tag,
+                    type_params,
+                    tpl,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ThisExpr {
-    #[doc = "Calls [VisitAll`::visit_this_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_this_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ThisExpr {
+    #[doc = "Calls [FoldAstPath`::fold_this_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_this_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ThisExpr { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ThisExpr(self::fields::ThisExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ThisExpr { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ThrowStmt {
-    #[doc = "Calls [VisitAll`::visit_throw_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_throw_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for ThrowStmt {
+    #[doc = "Calls [FoldAstPath`::fold_throw_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_throw_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             ThrowStmt { span, arg } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(arg, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::ThrowStmt(self::fields::ThrowStmtField::Arg));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                ThrowStmt { span, arg }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Tpl {
-    #[doc = "Calls [VisitAll`::visit_tpl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_tpl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Tpl {
+    #[doc = "Calls [FoldAstPath`::fold_tpl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_tpl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             Tpl {
                 span,
                 exprs,
                 quasis,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::Tpl(self::fields::TplField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Box<Expr>> as VisitAllWith<V>>::visit_with(exprs, visitor)
+                let exprs = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
+                        self::fields::TplField::Exprs(usize::MAX),
+                    ));
+                    <Vec<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        exprs,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TplElement> as VisitAllWith<V>>::visit_with(quasis, visitor)
+                let quasis = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::Tpl(
+                        self::fields::TplField::Quasis(usize::MAX),
+                    ));
+                    <Vec<TplElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        quasis,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                Tpl {
+                    span,
+                    exprs,
+                    quasis,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TplElement {
-    #[doc = "Calls [VisitAll`::visit_tpl_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_tpl_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TplElement {
+    #[doc = "Calls [FoldAstPath`::fold_tpl_element`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_tpl_element(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TplElement {
                 span,
@@ -151304,40 +130668,71 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TplElement {
                 cooked,
                 raw,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
+                        self::fields::TplElementField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(cooked, visitor)
+                let cooked = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
+                        self::fields::TplElementField::Cooked,
+                    ));
+                    <Option<swc_atoms::Atom> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        cooked,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
+                let raw = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TplElement(
+                        self::fields::TplElementField::Raw,
+                    ));
+                    <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(
+                        raw,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TplElement {
+                    span,
+                    tail,
+                    cooked,
+                    raw,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TruePlusMinus {
-    #[doc = "Calls [VisitAll`::visit_true_plus_minus`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_true_plus_minus(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TruePlusMinus {
+    #[doc = "Calls [FoldAstPath`::fold_true_plus_minus`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_true_plus_minus(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            TruePlusMinus::True => {}
-            TruePlusMinus::Plus => {}
-            TruePlusMinus::Minus => {}
+            TruePlusMinus::True => TruePlusMinus::True,
+            TruePlusMinus::Plus => TruePlusMinus::Plus,
+            TruePlusMinus::Minus => TruePlusMinus::Minus,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TryStmt {
-    #[doc = "Calls [VisitAll`::visit_try_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_try_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TryStmt {
+    #[doc = "Calls [FoldAstPath`::fold_try_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_try_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TryStmt {
                 span,
@@ -151345,74 +130740,150 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TryStmt {
                 handler,
                 finalizer,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <BlockStmt as VisitAllWith<V>>::visit_with(block, visitor)
+                let block = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Block));
+                    <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(
+                        block,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<CatchClause> as VisitAllWith<V>>::visit_with(handler, visitor)
+                let handler = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TryStmt(self::fields::TryStmtField::Handler));
+                    <Option<CatchClause> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        handler,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<BlockStmt> as VisitAllWith<V>>::visit_with(finalizer, visitor)
+                let finalizer = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TryStmt(
+                        self::fields::TryStmtField::Finalizer,
+                    ));
+                    <Option<BlockStmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        finalizer,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TryStmt {
+                    span,
+                    block,
+                    handler,
+                    finalizer,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsArrayType {
-    #[doc = "Calls [VisitAll`::visit_ts_array_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_array_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsArrayType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_array_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_array_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsArrayType { span, elem_type } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
+                        self::fields::TsArrayTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(elem_type, visitor)
+                let elem_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsArrayType(
+                        self::fields::TsArrayTypeField::ElemType,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        elem_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsArrayType { span, elem_type }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsAsExpr {
-    #[doc = "Calls [VisitAll`::visit_ts_as_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_as_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsAsExpr {
+    #[doc = "Calls [FoldAstPath`::fold_ts_as_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_as_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsAsExpr {
                 span,
                 expr,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsAsExpr(self::fields::TsAsExprField::Expr));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsAsExpr(
+                        self::fields::TsAsExprField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsAsExpr {
+                    span,
+                    expr,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsCallSignatureDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_call_signature_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_call_signature_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsCallSignatureDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_call_signature_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_call_signature_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsCallSignatureDecl {
                 span,
@@ -151420,32 +130891,65 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsCallSignatureDecl {
                 type_ann,
                 type_params,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsFnParam> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsCallSignatureDecl(
+                        self::fields::TsCallSignatureDeclField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                TsCallSignatureDecl {
+                    span,
+                    params,
+                    type_ann,
+                    type_params,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsConditionalType {
-    #[doc = "Calls [VisitAll`::visit_ts_conditional_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_conditional_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConditionalType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_conditional_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_conditional_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsConditionalType {
                 span,
@@ -151454,51 +130958,112 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsConditionalType {
                 true_type,
                 false_type,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(check_type, visitor)
+                let check_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::CheckType,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        check_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(extends_type, visitor)
+                let extends_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::ExtendsType,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        extends_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(true_type, visitor)
+                let true_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::TrueType,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        true_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(false_type, visitor)
+                let false_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConditionalType(
+                        self::fields::TsConditionalTypeField::FalseType,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        false_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsConditionalType {
+                    span,
+                    check_type,
+                    extends_type,
+                    true_type,
+                    false_type,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsConstAssertion {
-    #[doc = "Calls [VisitAll`::visit_ts_const_assertion`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_const_assertion(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstAssertion {
+    #[doc = "Calls [FoldAstPath`::fold_ts_const_assertion`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_const_assertion(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsConstAssertion { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
+                        self::fields::TsConstAssertionField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstAssertion(
+                        self::fields::TsConstAssertionField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsConstAssertion { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsConstructSignatureDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_construct_signature_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_construct_signature_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructSignatureDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_construct_signature_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_construct_signature_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsConstructSignatureDecl {
                 span,
@@ -151506,32 +131071,69 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsConstructSignatureDecl {
                 type_ann,
                 type_params,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsFnParam> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::Params(usize::MAX),
+                        ));
+                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::TypeAnn,
+                        ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsConstructSignatureDecl(
+                            self::fields::TsConstructSignatureDeclField::TypeParams,
+                        ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                TsConstructSignatureDecl {
+                    span,
+                    params,
+                    type_ann,
+                    type_params,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsConstructorType {
-    #[doc = "Calls [VisitAll`::visit_ts_constructor_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_constructor_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsConstructorType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_constructor_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_constructor_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsConstructorType {
                 span,
@@ -151540,49 +131142,101 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsConstructorType {
                 type_ann,
                 is_abstract,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsFnParam> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Box<TsTypeAnn> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsConstructorType(
+                        self::fields::TsConstructorTypeField::TypeAnn,
+                    ));
+                    <Box<TsTypeAnn> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsConstructorType {
+                    span,
+                    params,
+                    type_params,
+                    type_ann,
+                    is_abstract,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsEntityName {
-    #[doc = "Calls [VisitAll`::visit_ts_entity_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_entity_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEntityName {
+    #[doc = "Calls [FoldAstPath`::fold_ts_entity_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_entity_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsEntityName::TsQualifiedName { 0: _field_0 } => {
-                <Box<TsQualifiedName> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
+                    self::fields::TsEntityNameField::TsQualifiedName,
+                ));
+                let _field_0 = <Box<TsQualifiedName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsEntityName::TsQualifiedName { 0: _field_0 }
             }
             TsEntityName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEntityName(
+                    self::fields::TsEntityNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsEntityName::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsEnumDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_enum_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_enum_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_enum_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_enum_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsEnumDecl {
                 span,
@@ -151591,171 +131245,341 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsEnumDecl {
                 id,
                 members,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
+                        self::fields::TsEnumDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsEnumDecl(self::fields::TsEnumDeclField::Id));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
                 };
-                {
-                    <Vec<TsEnumMember> as VisitAllWith<V>>::visit_with(members, visitor)
+                let members = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumDecl(
+                        self::fields::TsEnumDeclField::Members(usize::MAX),
+                    ));
+                    <Vec<TsEnumMember> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        members,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsEnumDecl {
+                    span,
+                    declare,
+                    is_const,
+                    id,
+                    members,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsEnumMember {
-    #[doc = "Calls [VisitAll`::visit_ts_enum_member`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_enum_member(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumMember {
+    #[doc = "Calls [FoldAstPath`::fold_ts_enum_member`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_enum_member(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsEnumMember { span, id, init } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
+                        self::fields::TsEnumMemberField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsEnumMemberId as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
+                        self::fields::TsEnumMemberField::Id,
+                    ));
+                    <TsEnumMemberId as FoldWithAstPath<V>>::fold_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(init, visitor)
+                let init = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMember(
+                        self::fields::TsEnumMemberField::Init,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsEnumMember { span, id, init }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsEnumMemberId {
-    #[doc = "Calls [VisitAll`::visit_ts_enum_member_id`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_enum_member_id(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsEnumMemberId {
+    #[doc = "Calls [FoldAstPath`::fold_ts_enum_member_id`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_enum_member_id(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsEnumMemberId::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
+                    self::fields::TsEnumMemberIdField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsEnumMemberId::Ident { 0: _field_0 }
             }
             TsEnumMemberId::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsEnumMemberId(
+                    self::fields::TsEnumMemberIdField::Str,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsEnumMemberId::Str { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsExportAssignment {
-    #[doc = "Calls [VisitAll`::visit_ts_export_assignment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_export_assignment(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsExportAssignment {
+    #[doc = "Calls [FoldAstPath`::fold_ts_export_assignment`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_export_assignment(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsExportAssignment { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
+                        self::fields::TsExportAssignmentField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExportAssignment(
+                        self::fields::TsExportAssignmentField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsExportAssignment { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsExprWithTypeArgs {
-    #[doc = "Calls [VisitAll`::visit_ts_expr_with_type_args`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_expr_with_type_args(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsExprWithTypeArgs {
+    #[doc = "Calls [FoldAstPath`::fold_ts_expr_with_type_args`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_expr_with_type_args(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsExprWithTypeArgs {
                 span,
                 expr,
                 type_args,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
+                        self::fields::TsExprWithTypeArgsField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
+                        self::fields::TsExprWithTypeArgsField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExprWithTypeArgs(
+                        self::fields::TsExprWithTypeArgsField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
+                TsExprWithTypeArgs {
+                    span,
+                    expr,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsExternalModuleRef {
-    #[doc = "Calls [VisitAll`::visit_ts_external_module_ref`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_external_module_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsExternalModuleRef {
+    #[doc = "Calls [FoldAstPath`::fold_ts_external_module_ref`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_external_module_ref(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsExternalModuleRef { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
+                        self::fields::TsExternalModuleRefField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Str as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsExternalModuleRef(
+                        self::fields::TsExternalModuleRefField::Expr,
+                    ));
+                    <Str as FoldWithAstPath<V>>::fold_with_ast_path(expr, visitor, &mut *__ast_path)
                 };
+                TsExternalModuleRef { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsFnOrConstructorType {
-    #[doc = "Calls [VisitAll`::visit_ts_fn_or_constructor_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_fn_or_constructor_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnOrConstructorType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_fn_or_constructor_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_fn_or_constructor_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsFnOrConstructorType::TsFnType { 0: _field_0 } => {
-                <TsFnType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
+                    self::fields::TsFnOrConstructorTypeField::TsFnType,
+                ));
+                let _field_0 = <TsFnType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsFnOrConstructorType::TsFnType { 0: _field_0 }
             }
             TsFnOrConstructorType::TsConstructorType { 0: _field_0 } => {
-                <TsConstructorType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnOrConstructorType(
+                    self::fields::TsFnOrConstructorTypeField::TsConstructorType,
+                ));
+                let _field_0 = <TsConstructorType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsFnOrConstructorType::TsConstructorType { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsFnParam {
-    #[doc = "Calls [VisitAll`::visit_ts_fn_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_fn_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnParam {
+    #[doc = "Calls [FoldAstPath`::fold_ts_fn_param`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_fn_param(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsFnParam::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
+                    self::fields::TsFnParamField::Ident,
+                ));
+                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsFnParam::Ident { 0: _field_0 }
             }
             TsFnParam::Array { 0: _field_0 } => {
-                <ArrayPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
+                    self::fields::TsFnParamField::Array,
+                ));
+                let _field_0 = <ArrayPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsFnParam::Array { 0: _field_0 }
             }
             TsFnParam::Rest { 0: _field_0 } => {
-                <RestPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsFnParam(self::fields::TsFnParamField::Rest));
+                let _field_0 = <RestPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsFnParam::Rest { 0: _field_0 }
             }
             TsFnParam::Object { 0: _field_0 } => {
-                <ObjectPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnParam(
+                    self::fields::TsFnParamField::Object,
+                ));
+                let _field_0 = <ObjectPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsFnParam::Object { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsFnType {
-    #[doc = "Calls [VisitAll`::visit_ts_fn_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_fn_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsFnType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_fn_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_fn_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsFnType {
                 span,
@@ -151763,32 +131587,64 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsFnType {
                 type_params,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsFnType(self::fields::TsFnTypeField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsFnParam> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
+                        self::fields::TsFnTypeField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
+                        self::fields::TsFnTypeField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Box<TsTypeAnn> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsFnType(
+                        self::fields::TsFnTypeField::TypeAnn,
+                    ));
+                    <Box<TsTypeAnn> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsFnType {
+                    span,
+                    params,
+                    type_params,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsGetterSignature {
-    #[doc = "Calls [VisitAll`::visit_ts_getter_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_getter_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsGetterSignature {
+    #[doc = "Calls [FoldAstPath`::fold_ts_getter_signature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_getter_signature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsGetterSignature {
                 span,
@@ -151796,26 +131652,55 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsGetterSignature {
                 computed,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
+                        self::fields::TsGetterSignatureField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
+                        self::fields::TsGetterSignatureField::Key,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsGetterSignature(
+                        self::fields::TsGetterSignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsGetterSignature {
+                    span,
+                    key,
+                    computed,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsImportEqualsDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_import_equals_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_import_equals_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportEqualsDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_import_equals_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_import_equals_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsImportEqualsDecl {
                 span,
@@ -151824,26 +131709,52 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsImportEqualsDecl {
                 id,
                 module_ref,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
+                        self::fields::TsImportEqualsDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
+                        self::fields::TsImportEqualsDeclField::Id,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
                 };
-                {
-                    <TsModuleRef as VisitAllWith<V>>::visit_with(module_ref, visitor)
+                let module_ref = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportEqualsDecl(
+                        self::fields::TsImportEqualsDeclField::ModuleRef,
+                    ));
+                    <TsModuleRef as FoldWithAstPath<V>>::fold_with_ast_path(
+                        module_ref,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsImportEqualsDecl {
+                    span,
+                    is_export,
+                    is_type_only,
+                    id,
+                    module_ref,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsImportType {
-    #[doc = "Calls [VisitAll`::visit_ts_import_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_import_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsImportType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_import_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_import_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsImportType {
                 span,
@@ -151851,31 +131762,57 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsImportType {
                 qualifier,
                 type_args,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Str as VisitAllWith<V>>::visit_with(arg, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<TsEntityName> as VisitAllWith<V>>::visit_with(qualifier, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::Arg,
+                    ));
+                    <Str as FoldWithAstPath<V>>::fold_with_ast_path(arg, visitor, &mut *__ast_path)
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let qualifier = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::Qualifier,
+                    ));
+                    <Option<TsEntityName> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        qualifier,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsImportType(
+                        self::fields::TsImportTypeField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
+                TsImportType {
+                    span,
+                    arg,
+                    qualifier,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsIndexSignature {
-    #[doc = "Calls [VisitAll`::visit_ts_index_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_index_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexSignature {
+    #[doc = "Calls [FoldAstPath`::fold_ts_index_signature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_index_signature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsIndexSignature {
                 params,
@@ -151884,26 +131821,56 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsIndexSignature {
                 is_static,
                 span,
             } => {
-                {
-                    <Vec<TsFnParam> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
+                        self::fields::TsIndexSignatureField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
+                        self::fields::TsIndexSignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexSignature(
+                        self::fields::TsIndexSignatureField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsIndexSignature {
+                    params,
+                    type_ann,
+                    readonly,
+                    is_static,
+                    span,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsIndexedAccessType {
-    #[doc = "Calls [VisitAll`::visit_ts_indexed_access_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_indexed_access_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIndexedAccessType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_indexed_access_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_indexed_access_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsIndexedAccessType {
                 span,
@@ -151911,92 +131878,181 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsIndexedAccessType {
                 obj_type,
                 index_type,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
+                        self::fields::TsIndexedAccessTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(obj_type, visitor)
+                let obj_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
+                        self::fields::TsIndexedAccessTypeField::ObjType,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        obj_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(index_type, visitor)
+                let index_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIndexedAccessType(
+                        self::fields::TsIndexedAccessTypeField::IndexType,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        index_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsIndexedAccessType {
+                    span,
+                    readonly,
+                    obj_type,
+                    index_type,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsInferType {
-    #[doc = "Calls [VisitAll`::visit_ts_infer_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_infer_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInferType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_infer_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_infer_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsInferType { span, type_param } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
+                        self::fields::TsInferTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsTypeParam as VisitAllWith<V>>::visit_with(type_param, visitor)
+                let type_param = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInferType(
+                        self::fields::TsInferTypeField::TypeParam,
+                    ));
+                    <TsTypeParam as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsInferType { span, type_param }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsInstantiation {
-    #[doc = "Calls [VisitAll`::visit_ts_instantiation`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_instantiation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInstantiation {
+    #[doc = "Calls [FoldAstPath`::fold_ts_instantiation`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_instantiation(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsInstantiation {
                 span,
                 expr,
                 type_args,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
+                        self::fields::TsInstantiationField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
+                        self::fields::TsInstantiationField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsTypeParamInstantiation> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let type_args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInstantiation(
+                        self::fields::TsInstantiationField::TypeArgs,
+                    ));
+                    <Box<TsTypeParamInstantiation> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_args,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                TsInstantiation {
+                    span,
+                    expr,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsInterfaceBody {
-    #[doc = "Calls [VisitAll`::visit_ts_interface_body`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_interface_body(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInterfaceBody {
+    #[doc = "Calls [FoldAstPath`::fold_ts_interface_body`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_interface_body(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsInterfaceBody { span, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
+                        self::fields::TsInterfaceBodyField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsTypeElement> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceBody(
+                        self::fields::TsInterfaceBodyField::Body(usize::MAX),
+                    ));
+                    <Vec<TsTypeElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsInterfaceBody { span, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsInterfaceDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_interface_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_interface_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsInterfaceDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_interface_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_interface_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsInterfaceDecl {
                 span,
@@ -152006,142 +132062,268 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsInterfaceDecl {
                 extends,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Id,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Vec<TsExprWithTypeArgs> as VisitAllWith<V>>::visit_with(extends, visitor)
+                let extends = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Extends(usize::MAX),
+                    ));
+                    <Vec<TsExprWithTypeArgs> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        extends,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsInterfaceBody as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsInterfaceDecl(
+                        self::fields::TsInterfaceDeclField::Body,
+                    ));
+                    <TsInterfaceBody as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsInterfaceDecl {
+                    span,
+                    id,
+                    declare,
+                    type_params,
+                    extends,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsIntersectionType {
-    #[doc = "Calls [VisitAll`::visit_ts_intersection_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_intersection_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsIntersectionType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_intersection_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_intersection_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsIntersectionType { span, types } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
+                        self::fields::TsIntersectionTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Box<TsType>> as VisitAllWith<V>>::visit_with(types, visitor)
+                let types = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsIntersectionType(
+                        self::fields::TsIntersectionTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsIntersectionType { span, types }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsKeywordType {
-    #[doc = "Calls [VisitAll`::visit_ts_keyword_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_keyword_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsKeywordType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_keyword_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_keyword_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsKeywordType { span, kind } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
+                        self::fields::TsKeywordTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsKeywordTypeKind as VisitAllWith<V>>::visit_with(kind, visitor)
+                let kind = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsKeywordType(
+                        self::fields::TsKeywordTypeField::Kind,
+                    ));
+                    <TsKeywordTypeKind as FoldWithAstPath<V>>::fold_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsKeywordType { span, kind }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsKeywordTypeKind {
-    #[doc = "Calls [VisitAll`::visit_ts_keyword_type_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_keyword_type_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsKeywordTypeKind {
+    #[doc = "Calls [FoldAstPath`::fold_ts_keyword_type_kind`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_keyword_type_kind(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            TsKeywordTypeKind::TsAnyKeyword => {}
-            TsKeywordTypeKind::TsUnknownKeyword => {}
-            TsKeywordTypeKind::TsNumberKeyword => {}
-            TsKeywordTypeKind::TsObjectKeyword => {}
-            TsKeywordTypeKind::TsBooleanKeyword => {}
-            TsKeywordTypeKind::TsBigIntKeyword => {}
-            TsKeywordTypeKind::TsStringKeyword => {}
-            TsKeywordTypeKind::TsSymbolKeyword => {}
-            TsKeywordTypeKind::TsVoidKeyword => {}
-            TsKeywordTypeKind::TsUndefinedKeyword => {}
-            TsKeywordTypeKind::TsNullKeyword => {}
-            TsKeywordTypeKind::TsNeverKeyword => {}
-            TsKeywordTypeKind::TsIntrinsicKeyword => {}
+            TsKeywordTypeKind::TsAnyKeyword => TsKeywordTypeKind::TsAnyKeyword,
+            TsKeywordTypeKind::TsUnknownKeyword => TsKeywordTypeKind::TsUnknownKeyword,
+            TsKeywordTypeKind::TsNumberKeyword => TsKeywordTypeKind::TsNumberKeyword,
+            TsKeywordTypeKind::TsObjectKeyword => TsKeywordTypeKind::TsObjectKeyword,
+            TsKeywordTypeKind::TsBooleanKeyword => TsKeywordTypeKind::TsBooleanKeyword,
+            TsKeywordTypeKind::TsBigIntKeyword => TsKeywordTypeKind::TsBigIntKeyword,
+            TsKeywordTypeKind::TsStringKeyword => TsKeywordTypeKind::TsStringKeyword,
+            TsKeywordTypeKind::TsSymbolKeyword => TsKeywordTypeKind::TsSymbolKeyword,
+            TsKeywordTypeKind::TsVoidKeyword => TsKeywordTypeKind::TsVoidKeyword,
+            TsKeywordTypeKind::TsUndefinedKeyword => TsKeywordTypeKind::TsUndefinedKeyword,
+            TsKeywordTypeKind::TsNullKeyword => TsKeywordTypeKind::TsNullKeyword,
+            TsKeywordTypeKind::TsNeverKeyword => TsKeywordTypeKind::TsNeverKeyword,
+            TsKeywordTypeKind::TsIntrinsicKeyword => TsKeywordTypeKind::TsIntrinsicKeyword,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsLit {
-    #[doc = "Calls [VisitAll`::visit_ts_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsLit {
+    #[doc = "Calls [FoldAstPath`::fold_ts_lit`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_lit(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsLit::Number { 0: _field_0 } => {
-                <Number as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Number));
+                let _field_0 = <Number as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsLit::Number { 0: _field_0 }
             }
             TsLit::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Str));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsLit::Str { 0: _field_0 }
             }
             TsLit::Bool { 0: _field_0 } => {
-                <Bool as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Bool));
+                let _field_0 = <Bool as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsLit::Bool { 0: _field_0 }
             }
             TsLit::BigInt { 0: _field_0 } => {
-                <BigInt as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::BigInt));
+                let _field_0 = <BigInt as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsLit::BigInt { 0: _field_0 }
             }
             TsLit::Tpl { 0: _field_0 } => {
-                <TsTplLitType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsLit(self::fields::TsLitField::Tpl));
+                let _field_0 = <TsTplLitType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsLit::Tpl { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsLitType {
-    #[doc = "Calls [VisitAll`::visit_ts_lit_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_lit_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsLitType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_lit_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_lit_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsLitType { span, lit } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsLit as VisitAllWith<V>>::visit_with(lit, visitor)
+                let lit = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsLitType(self::fields::TsLitTypeField::Lit));
+                    <TsLit as FoldWithAstPath<V>>::fold_with_ast_path(
+                        lit,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsLitType { span, lit }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsMappedType {
-    #[doc = "Calls [VisitAll`::visit_ts_mapped_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_mapped_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsMappedType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_mapped_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_mapped_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsMappedType {
                 span,
@@ -152151,35 +132333,87 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsMappedType {
                 optional,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<TruePlusMinus> as VisitAllWith<V>>::visit_with(readonly, visitor)
+                let readonly = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::Readonly,
+                    ));
+                    <Option<TruePlusMinus> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        readonly,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsTypeParam as VisitAllWith<V>>::visit_with(type_param, visitor)
+                let type_param = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::TypeParam,
+                    ));
+                    <TsTypeParam as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsType>> as VisitAllWith<V>>::visit_with(name_type, visitor)
+                let name_type = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::NameType,
+                    ));
+                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name_type,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<TruePlusMinus> as VisitAllWith<V>>::visit_with(optional, visitor)
+                let optional = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::Optional,
+                    ));
+                    <Option<TruePlusMinus> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        optional,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsType>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMappedType(
+                        self::fields::TsMappedTypeField::TypeAnn,
+                    ));
+                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsMappedType {
+                    span,
+                    readonly,
+                    type_param,
+                    name_type,
+                    optional,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsMethodSignature {
-    #[doc = "Calls [VisitAll`::visit_ts_method_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_method_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsMethodSignature {
+    #[doc = "Calls [FoldAstPath`::fold_ts_method_signature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_method_signature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsMethodSignature {
                 span,
@@ -152190,54 +132424,114 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsMethodSignature {
                 type_ann,
                 type_params,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::Key,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsFnParam> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::Params(usize::MAX),
+                    ));
+                    <Vec<TsFnParam> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsMethodSignature(
+                        self::fields::TsMethodSignatureField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                TsMethodSignature {
+                    span,
+                    key,
+                    computed,
+                    optional,
+                    params,
+                    type_ann,
+                    type_params,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsModuleBlock {
-    #[doc = "Calls [VisitAll`::visit_ts_module_block`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_module_block(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleBlock {
+    #[doc = "Calls [FoldAstPath`::fold_ts_module_block`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_module_block(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsModuleBlock { span, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
+                        self::fields::TsModuleBlockField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<ModuleItem> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleBlock(
+                        self::fields::TsModuleBlockField::Body(usize::MAX),
+                    ));
+                    <Vec<ModuleItem> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsModuleBlock { span, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsModuleDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_module_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_module_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_module_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_module_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsModuleDecl {
                 span,
@@ -152246,77 +132540,161 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsModuleDecl {
                 id,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
+                        self::fields::TsModuleDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsModuleName as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
+                        self::fields::TsModuleDeclField::Id,
+                    ));
+                    <TsModuleName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        id,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<TsNamespaceBody> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleDecl(
+                        self::fields::TsModuleDeclField::Body,
+                    ));
+                    <Option<TsNamespaceBody> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsModuleDecl {
+                    span,
+                    declare,
+                    global,
+                    id,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsModuleName {
-    #[doc = "Calls [VisitAll`::visit_ts_module_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_module_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleName {
+    #[doc = "Calls [FoldAstPath`::fold_ts_module_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_module_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsModuleName::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
+                    self::fields::TsModuleNameField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsModuleName::Ident { 0: _field_0 }
             }
             TsModuleName::Str { 0: _field_0 } => {
-                <Str as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleName(
+                    self::fields::TsModuleNameField::Str,
+                ));
+                let _field_0 = <Str as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsModuleName::Str { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsModuleRef {
-    #[doc = "Calls [VisitAll`::visit_ts_module_ref`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_module_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsModuleRef {
+    #[doc = "Calls [FoldAstPath`::fold_ts_module_ref`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_module_ref(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsModuleRef::TsEntityName { 0: _field_0 } => {
-                <TsEntityName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
+                    self::fields::TsModuleRefField::TsEntityName,
+                ));
+                let _field_0 = <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsModuleRef::TsEntityName { 0: _field_0 }
             }
             TsModuleRef::TsExternalModuleRef { 0: _field_0 } => {
-                <TsExternalModuleRef as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsModuleRef(
+                    self::fields::TsModuleRefField::TsExternalModuleRef,
+                ));
+                let _field_0 = <TsExternalModuleRef as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsModuleRef::TsExternalModuleRef { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsNamespaceBody {
-    #[doc = "Calls [VisitAll`::visit_ts_namespace_body`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_namespace_body(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceBody {
+    #[doc = "Calls [FoldAstPath`::fold_ts_namespace_body`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_namespace_body(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsNamespaceBody::TsModuleBlock { 0: _field_0 } => {
-                <TsModuleBlock as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
+                    self::fields::TsNamespaceBodyField::TsModuleBlock,
+                ));
+                let _field_0 = <TsModuleBlock as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsNamespaceBody::TsModuleBlock { 0: _field_0 }
             }
             TsNamespaceBody::TsNamespaceDecl { 0: _field_0 } => {
-                <TsNamespaceDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceBody(
+                    self::fields::TsNamespaceBodyField::TsNamespaceDecl,
+                ));
+                let _field_0 = <TsNamespaceDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsNamespaceBody::TsNamespaceDecl { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsNamespaceDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_namespace_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_namespace_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_namespace_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_namespace_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsNamespaceDecl {
                 span,
@@ -152325,83 +132703,158 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsNamespaceDecl {
                 id,
                 body,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
+                        self::fields::TsNamespaceDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
+                        self::fields::TsNamespaceDeclField::Id,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
                 };
-                {
-                    <Box<TsNamespaceBody> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNamespaceDecl(
+                        self::fields::TsNamespaceDeclField::Body,
+                    ));
+                    <Box<TsNamespaceBody> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsNamespaceDecl {
+                    span,
+                    declare,
+                    global,
+                    id,
+                    body,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsNamespaceExportDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_namespace_export_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_namespace_export_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNamespaceExportDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_namespace_export_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_namespace_export_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsNamespaceExportDecl { span, id } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
+                            self::fields::TsNamespaceExportDeclField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsNamespaceExportDecl(
+                            self::fields::TsNamespaceExportDeclField::Id,
+                        ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
                 };
+                TsNamespaceExportDecl { span, id }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsNonNullExpr {
-    #[doc = "Calls [VisitAll`::visit_ts_non_null_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_non_null_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsNonNullExpr {
+    #[doc = "Calls [FoldAstPath`::fold_ts_non_null_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_non_null_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsNonNullExpr { span, expr } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
+                        self::fields::TsNonNullExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsNonNullExpr(
+                        self::fields::TsNonNullExprField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsNonNullExpr { span, expr }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsOptionalType {
-    #[doc = "Calls [VisitAll`::visit_ts_optional_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_optional_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsOptionalType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_optional_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_optional_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsOptionalType { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
+                        self::fields::TsOptionalTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsOptionalType(
+                        self::fields::TsOptionalTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsOptionalType { span, type_ann }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsParamProp {
-    #[doc = "Calls [VisitAll`::visit_ts_param_prop`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_param_prop(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParamProp {
+    #[doc = "Calls [FoldAstPath`::fold_ts_param_prop`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_param_prop(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsParamProp {
                 span,
@@ -152411,65 +132864,138 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsParamProp {
                 readonly,
                 param,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Decorator> as VisitAllWith<V>>::visit_with(decorators, visitor)
+                let decorators = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Decorators(usize::MAX),
+                    ));
+                    <Vec<Decorator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decorators,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Accessibility> as VisitAllWith<V>>::visit_with(accessibility, visitor)
+                let accessibility = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Accessibility,
+                    ));
+                    <Option<Accessibility> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        accessibility,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsParamPropParam as VisitAllWith<V>>::visit_with(param, visitor)
+                let param = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamProp(
+                        self::fields::TsParamPropField::Param,
+                    ));
+                    <TsParamPropParam as FoldWithAstPath<V>>::fold_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsParamProp {
+                    span,
+                    decorators,
+                    accessibility,
+                    is_override,
+                    readonly,
+                    param,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsParamPropParam {
-    #[doc = "Calls [VisitAll`::visit_ts_param_prop_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_param_prop_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParamPropParam {
+    #[doc = "Calls [FoldAstPath`::fold_ts_param_prop_param`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_param_prop_param(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsParamPropParam::Ident { 0: _field_0 } => {
-                <BindingIdent as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
+                    self::fields::TsParamPropParamField::Ident,
+                ));
+                let _field_0 = <BindingIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsParamPropParam::Ident { 0: _field_0 }
             }
             TsParamPropParam::Assign { 0: _field_0 } => {
-                <AssignPat as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParamPropParam(
+                    self::fields::TsParamPropParamField::Assign,
+                ));
+                let _field_0 = <AssignPat as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsParamPropParam::Assign { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsParenthesizedType {
-    #[doc = "Calls [VisitAll`::visit_ts_parenthesized_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_parenthesized_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsParenthesizedType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_parenthesized_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_parenthesized_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsParenthesizedType { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
+                        self::fields::TsParenthesizedTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsParenthesizedType(
+                        self::fields::TsParenthesizedTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsParenthesizedType { span, type_ann }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsPropertySignature {
-    #[doc = "Calls [VisitAll`::visit_ts_property_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_property_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsPropertySignature {
+    #[doc = "Calls [FoldAstPath`::fold_ts_property_signature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_property_signature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsPropertySignature {
                 span,
@@ -152479,93 +133005,193 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsPropertySignature {
                 optional,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
+                        self::fields::TsPropertySignatureField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
+                        self::fields::TsPropertySignatureField::Key,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsPropertySignature(
+                        self::fields::TsPropertySignatureField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsPropertySignature {
+                    span,
+                    readonly,
+                    key,
+                    computed,
+                    optional,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsQualifiedName {
-    #[doc = "Calls [VisitAll`::visit_ts_qualified_name`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_qualified_name(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsQualifiedName {
+    #[doc = "Calls [FoldAstPath`::fold_ts_qualified_name`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_qualified_name(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsQualifiedName { span, left, right } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
+                        self::fields::TsQualifiedNameField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsEntityName as VisitAllWith<V>>::visit_with(left, visitor)
+                let left = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
+                        self::fields::TsQualifiedNameField::Left,
+                    ));
+                    <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        left,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <IdentName as VisitAllWith<V>>::visit_with(right, visitor)
+                let right = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsQualifiedName(
+                        self::fields::TsQualifiedNameField::Right,
+                    ));
+                    <IdentName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        right,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsQualifiedName { span, left, right }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsRestType {
-    #[doc = "Calls [VisitAll`::visit_ts_rest_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_rest_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsRestType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_rest_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_rest_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsRestType { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
+                        self::fields::TsRestTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsRestType(
+                        self::fields::TsRestTypeField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsRestType { span, type_ann }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsSatisfiesExpr {
-    #[doc = "Calls [VisitAll`::visit_ts_satisfies_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_satisfies_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsSatisfiesExpr {
+    #[doc = "Calls [FoldAstPath`::fold_ts_satisfies_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_satisfies_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsSatisfiesExpr {
                 span,
                 expr,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
+                        self::fields::TsSatisfiesExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
+                        self::fields::TsSatisfiesExprField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSatisfiesExpr(
+                        self::fields::TsSatisfiesExprField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsSatisfiesExpr {
+                    span,
+                    expr,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsSetterSignature {
-    #[doc = "Calls [VisitAll`::visit_ts_setter_signature`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_setter_signature(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsSetterSignature {
+    #[doc = "Calls [FoldAstPath`::fold_ts_setter_signature`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_setter_signature(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsSetterSignature {
                 span,
@@ -152573,197 +133199,481 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsSetterSignature {
                 computed,
                 param,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
+                        self::fields::TsSetterSignatureField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(key, visitor)
+                let key = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
+                        self::fields::TsSetterSignatureField::Key,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        key,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsFnParam as VisitAllWith<V>>::visit_with(param, visitor)
+                let param = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsSetterSignature(
+                        self::fields::TsSetterSignatureField::Param,
+                    ));
+                    <TsFnParam as FoldWithAstPath<V>>::fold_with_ast_path(
+                        param,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsSetterSignature {
+                    span,
+                    key,
+                    computed,
+                    param,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsThisType {
-    #[doc = "Calls [VisitAll`::visit_ts_this_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_this_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsThisType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_this_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_this_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsThisType { span } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisType(
+                        self::fields::TsThisTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsThisType { span }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsThisTypeOrIdent {
-    #[doc = "Calls [VisitAll`::visit_ts_this_type_or_ident`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_this_type_or_ident(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsThisTypeOrIdent {
+    #[doc = "Calls [FoldAstPath`::fold_ts_this_type_or_ident`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_this_type_or_ident(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsThisTypeOrIdent::TsThisType { 0: _field_0 } => {
-                <TsThisType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
+                    self::fields::TsThisTypeOrIdentField::TsThisType,
+                ));
+                let _field_0 = <TsThisType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsThisTypeOrIdent::TsThisType { 0: _field_0 }
             }
             TsThisTypeOrIdent::Ident { 0: _field_0 } => {
-                <Ident as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsThisTypeOrIdent(
+                    self::fields::TsThisTypeOrIdentField::Ident,
+                ));
+                let _field_0 = <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsThisTypeOrIdent::Ident { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTplLitType {
-    #[doc = "Calls [VisitAll`::visit_ts_tpl_lit_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_tpl_lit_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTplLitType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_tpl_lit_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_tpl_lit_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTplLitType {
                 span,
                 types,
                 quasis,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
+                        self::fields::TsTplLitTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Box<TsType>> as VisitAllWith<V>>::visit_with(types, visitor)
+                let types = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
+                        self::fields::TsTplLitTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TplElement> as VisitAllWith<V>>::visit_with(quasis, visitor)
+                let quasis = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTplLitType(
+                        self::fields::TsTplLitTypeField::Quasis(usize::MAX),
+                    ));
+                    <Vec<TplElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        quasis,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTplLitType {
+                    span,
+                    types,
+                    quasis,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTupleElement {
-    #[doc = "Calls [VisitAll`::visit_ts_tuple_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_tuple_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTupleElement {
+    #[doc = "Calls [FoldAstPath`::fold_ts_tuple_element`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_tuple_element(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTupleElement { span, label, ty } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
+                        self::fields::TsTupleElementField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Pat> as VisitAllWith<V>>::visit_with(label, visitor)
+                let label = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
+                        self::fields::TsTupleElementField::Label,
+                    ));
+                    <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        label,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(ty, visitor)
+                let ty = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleElement(
+                        self::fields::TsTupleElementField::Ty,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ty,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTupleElement { span, label, ty }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTupleType {
-    #[doc = "Calls [VisitAll`::visit_ts_tuple_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_tuple_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTupleType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_tuple_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_tuple_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTupleType { span, elem_types } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
+                        self::fields::TsTupleTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsTupleElement> as VisitAllWith<V>>::visit_with(elem_types, visitor)
+                let elem_types = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTupleType(
+                        self::fields::TsTupleTypeField::ElemTypes(usize::MAX),
+                    ));
+                    <Vec<TsTupleElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        elem_types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTupleType { span, elem_types }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsType {
-    #[doc = "Calls [VisitAll`::visit_ts_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsType::TsKeywordType { 0: _field_0 } => {
-                <TsKeywordType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsKeywordType,
+                ));
+                let _field_0 = <TsKeywordType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsKeywordType { 0: _field_0 }
             }
             TsType::TsThisType { 0: _field_0 } => {
-                <TsThisType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsThisType));
+                let _field_0 = <TsThisType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsThisType { 0: _field_0 }
             }
             TsType::TsFnOrConstructorType { 0: _field_0 } => {
-                <TsFnOrConstructorType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsFnOrConstructorType,
+                ));
+                let _field_0 = <TsFnOrConstructorType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsFnOrConstructorType { 0: _field_0 }
             }
             TsType::TsTypeRef { 0: _field_0 } => {
-                <TsTypeRef as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeRef));
+                let _field_0 = <TsTypeRef as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsTypeRef { 0: _field_0 }
             }
             TsType::TsTypeQuery { 0: _field_0 } => {
-                <TsTypeQuery as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTypeQuery,
+                ));
+                let _field_0 = <TsTypeQuery as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsTypeQuery { 0: _field_0 }
             }
             TsType::TsTypeLit { 0: _field_0 } => {
-                <TsTypeLit as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsTypeLit));
+                let _field_0 = <TsTypeLit as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsTypeLit { 0: _field_0 }
             }
             TsType::TsArrayType { 0: _field_0 } => {
-                <TsArrayType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsArrayType,
+                ));
+                let _field_0 = <TsArrayType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsArrayType { 0: _field_0 }
             }
             TsType::TsTupleType { 0: _field_0 } => {
-                <TsTupleType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTupleType,
+                ));
+                let _field_0 = <TsTupleType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsTupleType { 0: _field_0 }
             }
             TsType::TsOptionalType { 0: _field_0 } => {
-                <TsOptionalType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsOptionalType,
+                ));
+                let _field_0 = <TsOptionalType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsOptionalType { 0: _field_0 }
             }
             TsType::TsRestType { 0: _field_0 } => {
-                <TsRestType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsRestType));
+                let _field_0 = <TsRestType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsRestType { 0: _field_0 }
             }
             TsType::TsUnionOrIntersectionType { 0: _field_0 } => {
-                <TsUnionOrIntersectionType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsUnionOrIntersectionType,
+                ));
+                let _field_0 =
+                    <TsUnionOrIntersectionType as FoldWithAstPath<V>>::fold_with_ast_path(
+                        _field_0,
+                        visitor,
+                        &mut *__ast_path,
+                    );
+                TsType::TsUnionOrIntersectionType { 0: _field_0 }
             }
             TsType::TsConditionalType { 0: _field_0 } => {
-                <TsConditionalType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsConditionalType,
+                ));
+                let _field_0 = <TsConditionalType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsConditionalType { 0: _field_0 }
             }
             TsType::TsInferType { 0: _field_0 } => {
-                <TsInferType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsInferType,
+                ));
+                let _field_0 = <TsInferType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsInferType { 0: _field_0 }
             }
             TsType::TsParenthesizedType { 0: _field_0 } => {
-                <TsParenthesizedType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsParenthesizedType,
+                ));
+                let _field_0 = <TsParenthesizedType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsParenthesizedType { 0: _field_0 }
             }
             TsType::TsTypeOperator { 0: _field_0 } => {
-                <TsTypeOperator as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTypeOperator,
+                ));
+                let _field_0 = <TsTypeOperator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsTypeOperator { 0: _field_0 }
             }
             TsType::TsIndexedAccessType { 0: _field_0 } => {
-                <TsIndexedAccessType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsIndexedAccessType,
+                ));
+                let _field_0 = <TsIndexedAccessType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsIndexedAccessType { 0: _field_0 }
             }
             TsType::TsMappedType { 0: _field_0 } => {
-                <TsMappedType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsMappedType,
+                ));
+                let _field_0 = <TsMappedType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsMappedType { 0: _field_0 }
             }
             TsType::TsLitType { 0: _field_0 } => {
-                <TsLitType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path
+                    .with_guard(AstParentKind::TsType(self::fields::TsTypeField::TsLitType));
+                let _field_0 = <TsLitType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsLitType { 0: _field_0 }
             }
             TsType::TsTypePredicate { 0: _field_0 } => {
-                <TsTypePredicate as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsTypePredicate,
+                ));
+                let _field_0 = <TsTypePredicate as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsTypePredicate { 0: _field_0 }
             }
             TsType::TsImportType { 0: _field_0 } => {
-                <TsImportType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsType(
+                    self::fields::TsTypeField::TsImportType,
+                ));
+                let _field_0 = <TsImportType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsType::TsImportType { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeAliasDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_type_alias_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_alias_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAliasDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_alias_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_alias_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeAliasDecl {
                 span,
@@ -152772,164 +133682,338 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeAliasDecl {
                 type_params,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(id, visitor)
+                let id = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::Id,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(id, visitor, &mut *__ast_path)
                 };
-                {
-                    <Option<Box<TsTypeParamDecl>> as VisitAllWith<V>>::visit_with(
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::TypeParams,
+                    ));
+                    <Option<Box<TsTypeParamDecl>> as FoldWithAstPath<V>>::fold_with_ast_path(
                         type_params,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAliasDecl(
+                        self::fields::TsTypeAliasDeclField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeAliasDecl {
+                    span,
+                    declare,
+                    id,
+                    type_params,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeAnn {
-    #[doc = "Calls [VisitAll`::visit_ts_type_ann`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_ann(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAnn {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_ann`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_ann(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeAnn { span, type_ann } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsTypeAnn(self::fields::TsTypeAnnField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAnn(
+                        self::fields::TsTypeAnnField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeAnn { span, type_ann }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeAssertion {
-    #[doc = "Calls [VisitAll`::visit_ts_type_assertion`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_assertion(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeAssertion {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_assertion`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_assertion(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeAssertion {
                 span,
                 expr,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
+                        self::fields::TsTypeAssertionField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(expr, visitor)
+                let expr = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
+                        self::fields::TsTypeAssertionField::Expr,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeAssertion(
+                        self::fields::TsTypeAssertionField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeAssertion {
+                    span,
+                    expr,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeElement {
-    #[doc = "Calls [VisitAll`::visit_ts_type_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_element(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeElement {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_element`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_element(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeElement::TsCallSignatureDecl { 0: _field_0 } => {
-                <TsCallSignatureDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsCallSignatureDecl,
+                ));
+                let _field_0 = <TsCallSignatureDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeElement::TsCallSignatureDecl { 0: _field_0 }
             }
             TsTypeElement::TsConstructSignatureDecl { 0: _field_0 } => {
-                <TsConstructSignatureDecl as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsConstructSignatureDecl,
+                ));
+                let _field_0 = <TsConstructSignatureDecl as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeElement::TsConstructSignatureDecl { 0: _field_0 }
             }
             TsTypeElement::TsPropertySignature { 0: _field_0 } => {
-                <TsPropertySignature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsPropertySignature,
+                ));
+                let _field_0 = <TsPropertySignature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeElement::TsPropertySignature { 0: _field_0 }
             }
             TsTypeElement::TsGetterSignature { 0: _field_0 } => {
-                <TsGetterSignature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsGetterSignature,
+                ));
+                let _field_0 = <TsGetterSignature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeElement::TsGetterSignature { 0: _field_0 }
             }
             TsTypeElement::TsSetterSignature { 0: _field_0 } => {
-                <TsSetterSignature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsSetterSignature,
+                ));
+                let _field_0 = <TsSetterSignature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeElement::TsSetterSignature { 0: _field_0 }
             }
             TsTypeElement::TsMethodSignature { 0: _field_0 } => {
-                <TsMethodSignature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsMethodSignature,
+                ));
+                let _field_0 = <TsMethodSignature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeElement::TsMethodSignature { 0: _field_0 }
             }
             TsTypeElement::TsIndexSignature { 0: _field_0 } => {
-                <TsIndexSignature as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeElement(
+                    self::fields::TsTypeElementField::TsIndexSignature,
+                ));
+                let _field_0 = <TsIndexSignature as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeElement::TsIndexSignature { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeLit {
-    #[doc = "Calls [VisitAll`::visit_ts_type_lit`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_lit(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeLit {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_lit`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_lit(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeLit { span, members } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsTypeLit(self::fields::TsTypeLitField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsTypeElement> as VisitAllWith<V>>::visit_with(members, visitor)
+                let members = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeLit(
+                        self::fields::TsTypeLitField::Members(usize::MAX),
+                    ));
+                    <Vec<TsTypeElement> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        members,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeLit { span, members }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeOperator {
-    #[doc = "Calls [VisitAll`::visit_ts_type_operator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_operator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeOperator {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_operator`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_operator(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeOperator { span, op, type_ann } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
+                        self::fields::TsTypeOperatorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsTypeOperatorOp as VisitAllWith<V>>::visit_with(op, visitor)
+                let op = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
+                        self::fields::TsTypeOperatorField::Op,
+                    ));
+                    <TsTypeOperatorOp as FoldWithAstPath<V>>::fold_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<TsType> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeOperator(
+                        self::fields::TsTypeOperatorField::TypeAnn,
+                    ));
+                    <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeOperator { span, op, type_ann }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeOperatorOp {
-    #[doc = "Calls [VisitAll`::visit_ts_type_operator_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_operator_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeOperatorOp {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_operator_op`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_operator_op(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            TsTypeOperatorOp::KeyOf => {}
-            TsTypeOperatorOp::Unique => {}
-            TsTypeOperatorOp::ReadOnly => {}
+            TsTypeOperatorOp::KeyOf => TsTypeOperatorOp::KeyOf,
+            TsTypeOperatorOp::Unique => TsTypeOperatorOp::Unique,
+            TsTypeOperatorOp::ReadOnly => TsTypeOperatorOp::ReadOnly,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeParam {
-    #[doc = "Calls [VisitAll`::visit_ts_type_param`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_param(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParam {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_param`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_param(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeParam {
                 span,
@@ -152940,67 +134024,142 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeParam {
                 constraint,
                 default,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Ident as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Name,
+                    ));
+                    <Ident as FoldWithAstPath<V>>::fold_with_ast_path(
+                        name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsType>> as VisitAllWith<V>>::visit_with(constraint, visitor)
+                let constraint = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Constraint,
+                    ));
+                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        constraint,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsType>> as VisitAllWith<V>>::visit_with(default, visitor)
+                let default = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParam(
+                        self::fields::TsTypeParamField::Default,
+                    ));
+                    <Option<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        default,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeParam {
+                    span,
+                    name,
+                    is_in,
+                    is_out,
+                    is_const,
+                    constraint,
+                    default,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeParamDecl {
-    #[doc = "Calls [VisitAll`::visit_ts_type_param_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_param_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParamDecl {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_param_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_param_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeParamDecl { span, params } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
+                        self::fields::TsTypeParamDeclField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<TsTypeParam> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeParamDecl(
+                        self::fields::TsTypeParamDeclField::Params(usize::MAX),
+                    ));
+                    <Vec<TsTypeParam> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeParamDecl { span, params }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeParamInstantiation {
-    #[doc = "Calls [VisitAll`::visit_ts_type_param_instantiation`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_param_instantiation(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeParamInstantiation {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_param_instantiation`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_param_instantiation(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeParamInstantiation { span, params } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
+                            self::fields::TsTypeParamInstantiationField::Span,
+                        ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Box<TsType>> as VisitAllWith<V>>::visit_with(params, visitor)
+                let params = {
+                    let mut __ast_path =
+                        __ast_path.with_guard(AstParentKind::TsTypeParamInstantiation(
+                            self::fields::TsTypeParamInstantiationField::Params(usize::MAX),
+                        ));
+                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        params,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypeParamInstantiation { span, params }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypePredicate {
-    #[doc = "Calls [VisitAll`::visit_ts_type_predicate`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_predicate(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypePredicate {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_predicate`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_predicate(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypePredicate {
                 span,
@@ -153008,176 +134167,325 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypePredicate {
                 param_name,
                 type_ann,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
+                        self::fields::TsTypePredicateField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <TsThisTypeOrIdent as VisitAllWith<V>>::visit_with(param_name, visitor)
+                let param_name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
+                        self::fields::TsTypePredicateField::ParamName,
+                    ));
+                    <TsThisTypeOrIdent as FoldWithAstPath<V>>::fold_with_ast_path(
+                        param_name,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeAnn>> as VisitAllWith<V>>::visit_with(type_ann, visitor)
+                let type_ann = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypePredicate(
+                        self::fields::TsTypePredicateField::TypeAnn,
+                    ));
+                    <Option<Box<TsTypeAnn>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_ann,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsTypePredicate {
+                    span,
+                    asserts,
+                    param_name,
+                    type_ann,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeQuery {
-    #[doc = "Calls [VisitAll`::visit_ts_type_query`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_query(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeQuery {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_query`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_query(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeQuery {
                 span,
                 expr_name,
                 type_args,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsTypeQueryExpr as VisitAllWith<V>>::visit_with(expr_name, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
+                        self::fields::TsTypeQueryField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_args, visitor,
+                let expr_name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
+                        self::fields::TsTypeQueryField::ExprName,
+                    ));
+                    <TsTypeQueryExpr as FoldWithAstPath<V>>::fold_with_ast_path(
+                        expr_name,
+                        visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_args = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQuery(
+                        self::fields::TsTypeQueryField::TypeArgs,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_args , visitor , & mut * __ast_path)
+                };
+                TsTypeQuery {
+                    span,
+                    expr_name,
+                    type_args,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeQueryExpr {
-    #[doc = "Calls [VisitAll`::visit_ts_type_query_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_query_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeQueryExpr {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_query_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_query_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeQueryExpr::TsEntityName { 0: _field_0 } => {
-                <TsEntityName as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
+                    self::fields::TsTypeQueryExprField::TsEntityName,
+                ));
+                let _field_0 = <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeQueryExpr::TsEntityName { 0: _field_0 }
             }
             TsTypeQueryExpr::Import { 0: _field_0 } => {
-                <TsImportType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeQueryExpr(
+                    self::fields::TsTypeQueryExprField::Import,
+                ));
+                let _field_0 = <TsImportType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsTypeQueryExpr::Import { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsTypeRef {
-    #[doc = "Calls [VisitAll`::visit_ts_type_ref`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_ref(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsTypeRef {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_ref`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_ref(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsTypeRef {
                 span,
                 type_name,
                 type_params,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <TsEntityName as VisitAllWith<V>>::visit_with(type_name, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::TsTypeRef(self::fields::TsTypeRefField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<TsTypeParamInstantiation>> as VisitAllWith<V>>::visit_with(
-                        type_params,
+                let type_name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
+                        self::fields::TsTypeRefField::TypeName,
+                    ));
+                    <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(
+                        type_name,
                         visitor,
+                        &mut *__ast_path,
                     )
                 };
+                let type_params = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsTypeRef(
+                        self::fields::TsTypeRefField::TypeParams,
+                    ));
+                    < Option < Box < TsTypeParamInstantiation > > as FoldWithAstPath < V > > :: fold_with_ast_path (type_params , visitor , & mut * __ast_path)
+                };
+                TsTypeRef {
+                    span,
+                    type_name,
+                    type_params,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsUnionOrIntersectionType {
-    #[doc = "Calls [VisitAll`::visit_ts_union_or_intersection_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_union_or_intersection_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsUnionOrIntersectionType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_union_or_intersection_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_union_or_intersection_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsUnionOrIntersectionType::TsUnionType { 0: _field_0 } => {
-                <TsUnionType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
+                        self::fields::TsUnionOrIntersectionTypeField::TsUnionType,
+                    ));
+                let _field_0 = <TsUnionType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsUnionOrIntersectionType::TsUnionType { 0: _field_0 }
             }
             TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 } => {
-                <TsIntersectionType as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path =
+                    __ast_path.with_guard(AstParentKind::TsUnionOrIntersectionType(
+                        self::fields::TsUnionOrIntersectionTypeField::TsIntersectionType,
+                    ));
+                let _field_0 = <TsIntersectionType as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                TsUnionOrIntersectionType::TsIntersectionType { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TsUnionType {
-    #[doc = "Calls [VisitAll`::visit_ts_union_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_union_type(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TsUnionType {
+    #[doc = "Calls [FoldAstPath`::fold_ts_union_type`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_union_type(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             TsUnionType { span, types } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
+                        self::fields::TsUnionTypeField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<Box<TsType>> as VisitAllWith<V>>::visit_with(types, visitor)
+                let types = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::TsUnionType(
+                        self::fields::TsUnionTypeField::Types(usize::MAX),
+                    ));
+                    <Vec<Box<TsType>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        types,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                TsUnionType { span, types }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UnaryExpr {
-    #[doc = "Calls [VisitAll`::visit_unary_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_unary_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnaryExpr {
+    #[doc = "Calls [FoldAstPath`::fold_unary_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_unary_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UnaryExpr { span, op, arg } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <UnaryOp as VisitAllWith<V>>::visit_with(op, visitor)
+                let op = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Op));
+                    <UnaryOp as FoldWithAstPath<V>>::fold_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(arg, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UnaryExpr(self::fields::UnaryExprField::Arg));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                UnaryExpr { span, op, arg }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UnaryOp {
-    #[doc = "Calls [VisitAll`::visit_unary_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_unary_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UnaryOp {
+    #[doc = "Calls [FoldAstPath`::fold_unary_op`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_unary_op(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            UnaryOp::Minus => {}
-            UnaryOp::Plus => {}
-            UnaryOp::Bang => {}
-            UnaryOp::Tilde => {}
-            UnaryOp::TypeOf => {}
-            UnaryOp::Void => {}
-            UnaryOp::Delete => {}
+            UnaryOp::Minus => UnaryOp::Minus,
+            UnaryOp::Plus => UnaryOp::Plus,
+            UnaryOp::Bang => UnaryOp::Bang,
+            UnaryOp::Tilde => UnaryOp::Tilde,
+            UnaryOp::TypeOf => UnaryOp::TypeOf,
+            UnaryOp::Void => UnaryOp::Void,
+            UnaryOp::Delete => UnaryOp::Delete,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UpdateExpr {
-    #[doc = "Calls [VisitAll`::visit_update_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_update_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UpdateExpr {
+    #[doc = "Calls [FoldAstPath`::fold_update_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_update_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UpdateExpr {
                 span,
@@ -153185,62 +134493,112 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for UpdateExpr {
                 prefix,
                 arg,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
+                        self::fields::UpdateExprField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <UpdateOp as VisitAllWith<V>>::visit_with(op, visitor)
+                let op = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UpdateExpr(self::fields::UpdateExprField::Op));
+                    <UpdateOp as FoldWithAstPath<V>>::fold_with_ast_path(
+                        op,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(arg, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UpdateExpr(
+                        self::fields::UpdateExprField::Arg,
+                    ));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                UpdateExpr {
+                    span,
+                    op,
+                    prefix,
+                    arg,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UpdateOp {
-    #[doc = "Calls [VisitAll`::visit_update_op`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_update_op(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UpdateOp {
+    #[doc = "Calls [FoldAstPath`::fold_update_op`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_update_op(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            UpdateOp::PlusPlus => {}
-            UpdateOp::MinusMinus => {}
+            UpdateOp::PlusPlus => UpdateOp::PlusPlus,
+            UpdateOp::MinusMinus => UpdateOp::MinusMinus,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for UsingDecl {
-    #[doc = "Calls [VisitAll`::visit_using_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_using_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for UsingDecl {
+    #[doc = "Calls [FoldAstPath`::fold_using_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_using_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             UsingDecl {
                 span,
                 is_await,
                 decls,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::UsingDecl(self::fields::UsingDeclField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<VarDeclarator> as VisitAllWith<V>>::visit_with(decls, visitor)
+                let decls = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::UsingDecl(
+                        self::fields::UsingDeclField::Decls(usize::MAX),
+                    ));
+                    <Vec<VarDeclarator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decls,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                UsingDecl {
+                    span,
+                    is_await,
+                    decls,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for VarDecl {
-    #[doc = "Calls [VisitAll`::visit_var_decl`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_var_decl(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDecl {
+    #[doc = "Calls [FoldAstPath`::fold_var_decl`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_var_decl(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             VarDecl {
                 span,
@@ -153249,60 +134607,114 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for VarDecl {
                 declare,
                 decls,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <swc_common::SyntaxContext as VisitAllWith<V>>::visit_with(ctxt, visitor)
+                let ctxt = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Ctxt));
+                    <swc_common::SyntaxContext as FoldWithAstPath<V>>::fold_with_ast_path(
+                        ctxt,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <VarDeclKind as VisitAllWith<V>>::visit_with(kind, visitor)
+                let kind = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::VarDecl(self::fields::VarDeclField::Kind));
+                    <VarDeclKind as FoldWithAstPath<V>>::fold_with_ast_path(
+                        kind,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Vec<VarDeclarator> as VisitAllWith<V>>::visit_with(decls, visitor)
+                let decls = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDecl(
+                        self::fields::VarDeclField::Decls(usize::MAX),
+                    ));
+                    <Vec<VarDeclarator> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        decls,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                VarDecl {
+                    span,
+                    ctxt,
+                    kind,
+                    declare,
+                    decls,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for VarDeclKind {
-    #[doc = "Calls [VisitAll`::visit_var_decl_kind`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_var_decl_kind(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclKind {
+    #[doc = "Calls [FoldAstPath`::fold_var_decl_kind`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_var_decl_kind(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
-            VarDeclKind::Var => {}
-            VarDeclKind::Let => {}
-            VarDeclKind::Const => {}
+            VarDeclKind::Var => VarDeclKind::Var,
+            VarDeclKind::Let => VarDeclKind::Let,
+            VarDeclKind::Const => VarDeclKind::Const,
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for VarDeclOrExpr {
-    #[doc = "Calls [VisitAll`::visit_var_decl_or_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_var_decl_or_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclOrExpr {
+    #[doc = "Calls [FoldAstPath`::fold_var_decl_or_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_var_decl_or_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             VarDeclOrExpr::VarDecl { 0: _field_0 } => {
-                <Box<VarDecl> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
+                    self::fields::VarDeclOrExprField::VarDecl,
+                ));
+                let _field_0 = <Box<VarDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                VarDeclOrExpr::VarDecl { 0: _field_0 }
             }
             VarDeclOrExpr::Expr { 0: _field_0 } => {
-                <Box<Expr> as VisitAllWith<V>>::visit_with(_field_0, visitor);
+                let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclOrExpr(
+                    self::fields::VarDeclOrExprField::Expr,
+                ));
+                let _field_0 = <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    _field_0,
+                    visitor,
+                    &mut *__ast_path,
+                );
+                VarDeclOrExpr::Expr { 0: _field_0 }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for VarDeclarator {
-    #[doc = "Calls [VisitAll`::visit_var_declarator`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_var_declarator(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for VarDeclarator {
+    #[doc = "Calls [FoldAstPath`::fold_var_declarator`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_var_declarator(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             VarDeclarator {
                 span,
@@ -153310,892 +134722,1297 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for VarDeclarator {
                 init,
                 definite,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
+                        self::fields::VarDeclaratorField::Span,
+                    ));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Pat as VisitAllWith<V>>::visit_with(name, visitor)
+                let name = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
+                        self::fields::VarDeclaratorField::Name,
+                    ));
+                    <Pat as FoldWithAstPath<V>>::fold_with_ast_path(name, visitor, &mut *__ast_path)
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(init, visitor)
+                let init = {
+                    let mut __ast_path = __ast_path.with_guard(AstParentKind::VarDeclarator(
+                        self::fields::VarDeclaratorField::Init,
+                    ));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        init,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                VarDeclarator {
+                    span,
+                    name,
+                    init,
+                    definite,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for WhileStmt {
-    #[doc = "Calls [VisitAll`::visit_while_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_while_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WhileStmt {
+    #[doc = "Calls [FoldAstPath`::fold_while_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_while_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             WhileStmt { span, test, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(test, visitor)
+                let test = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Test));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        test,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WhileStmt(self::fields::WhileStmtField::Body));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                WhileStmt { span, test, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for WithStmt {
-    #[doc = "Calls [VisitAll`::visit_with_stmt`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_with_stmt(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WithStmt {
+    #[doc = "Calls [FoldAstPath`::fold_with_stmt`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_with_stmt(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             WithStmt { span, obj, body } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Expr> as VisitAllWith<V>>::visit_with(obj, visitor)
+                let obj = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Obj));
+                    <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        obj,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Box<Stmt> as VisitAllWith<V>>::visit_with(body, visitor)
+                let body = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::WithStmt(self::fields::WithStmtField::Body));
+                    <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        body,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                WithStmt { span, obj, body }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for YieldExpr {
-    #[doc = "Calls [VisitAll`::visit_yield_expr`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_yield_expr(visitor, self)
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for YieldExpr {
+    #[doc = "Calls [FoldAstPath`::fold_yield_expr`] with `self`."]
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_yield_expr(visitor, self, __ast_path)
     }
 
-    fn visit_children_with(&self, visitor: &mut V) {
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         match self {
             YieldExpr {
                 span,
                 arg,
                 delegate,
             } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
+                let span = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Span));
+                    <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(
+                        span,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
-                {
-                    <Option<Box<Expr>> as VisitAllWith<V>>::visit_with(arg, visitor)
+                let arg = {
+                    let mut __ast_path = __ast_path
+                        .with_guard(AstParentKind::YieldExpr(self::fields::YieldExprField::Arg));
+                    <Option<Box<Expr>> as FoldWithAstPath<V>>::fold_with_ast_path(
+                        arg,
+                        visitor,
+                        &mut *__ast_path,
+                    )
                 };
+                YieldExpr {
+                    span,
+                    arg,
+                    delegate,
+                }
             }
         }
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitAll`::visit_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for BigIntValue {
-    #[doc = "Calls [VisitAll`::visit_big_int_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
+    #[doc = "Calls [FoldAstPath`::fold_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_big_int_value(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ClassMember] {
-    #[doc = "Calls [VisitAll`::visit_class_members`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BigIntValue {
+    #[doc = "Calls [FoldAstPath`::fold_big_int_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_class_members(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_big_int_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ClassMember as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Decorator] {
-    #[doc = "Calls [VisitAll`::visit_decorators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ClassMember> {
+    #[doc = "Calls [FoldAstPath`::fold_class_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_decorators(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_class_members(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Decorator as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ClassMember as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ExportSpecifier] {
-    #[doc = "Calls [VisitAll`::visit_export_specifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Decorator> {
+    #[doc = "Calls [FoldAstPath`::fold_decorators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_export_specifiers(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_decorators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ExportSpecifier as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Decorator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ExprOrSpread] {
-    #[doc = "Calls [VisitAll`::visit_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ExportSpecifier> {
+    #[doc = "Calls [FoldAstPath`::fold_export_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_expr_or_spreads(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_export_specifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ExprOrSpread as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ExportSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Box<Expr>] {
-    #[doc = "Calls [VisitAll`::visit_exprs`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ExprOrSpread> {
+    #[doc = "Calls [FoldAstPath`::fold_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_exprs(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Box<Expr> as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ExprOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ImportSpecifier] {
-    #[doc = "Calls [VisitAll`::visit_import_specifiers`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Box<Expr>> {
+    #[doc = "Calls [FoldAstPath`::fold_exprs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_specifiers(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_exprs(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ImportSpecifier as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ImportWithItem] {
-    #[doc = "Calls [VisitAll`::visit_import_with_items`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ImportSpecifier> {
+    #[doc = "Calls [FoldAstPath`::fold_import_specifiers`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_import_with_items(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_specifiers(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ImportWithItem as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ImportSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [JSXAttrOrSpread] {
-    #[doc = "Calls [VisitAll`::visit_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ImportWithItem> {
+    #[doc = "Calls [FoldAstPath`::fold_import_with_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_attr_or_spreads(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_import_with_items(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <JSXAttrOrSpread as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ImportWithItem as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [JSXElementChild] {
-    #[doc = "Calls [VisitAll`::visit_jsx_element_childs`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<JSXAttrOrSpread> {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_jsx_element_childs(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_attr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <JSXElementChild as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <JSXAttrOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ModuleItem] {
-    #[doc = "Calls [VisitAll`::visit_module_items`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<JSXElementChild> {
+    #[doc = "Calls [FoldAstPath`::fold_jsx_element_childs`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_module_items(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_jsx_element_childs(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ModuleItem as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <JSXElementChild as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ObjectPatProp] {
-    #[doc = "Calls [VisitAll`::visit_object_pat_props`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ModuleItem> {
+    #[doc = "Calls [FoldAstPath`::fold_module_items`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_object_pat_props(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_module_items(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ObjectPatProp as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ModuleItem as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Accessibility> {
-    #[doc = "Calls [VisitAll`::visit_opt_accessibility`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ObjectPatProp> {
+    #[doc = "Calls [FoldAstPath`::fold_object_pat_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_accessibility(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_object_pat_props(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Accessibility as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ObjectPatProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitAll`::visit_opt_atom`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Accessibility> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_accessibility`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_atom(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_accessibility(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_atoms::Atom as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Accessibility as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<BlockStmt> {
-    #[doc = "Calls [VisitAll`::visit_opt_block_stmt`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_atom`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_block_stmt(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_atom(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <BlockStmt as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <swc_atoms::Atom as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<CatchClause> {
-    #[doc = "Calls [VisitAll`::visit_opt_catch_clause`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<BlockStmt> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_block_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_catch_clause(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_block_stmt(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <CatchClause as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <BlockStmt as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Expr>> {
-    #[doc = "Calls [VisitAll`::visit_opt_expr`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<CatchClause> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_catch_clause`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_expr(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_catch_clause(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Expr> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <CatchClause as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ExprOrSpread> {
-    #[doc = "Calls [VisitAll`::visit_opt_expr_or_spread`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Expr>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_expr_or_spread(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_expr(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ExprOrSpread as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<ExprOrSpread>> {
-    #[doc = "Calls [VisitAll`::visit_opt_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ExprOrSpread> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_expr_or_spread`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_expr_or_spreads(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_expr_or_spread(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Vec<ExprOrSpread> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <ExprOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Ident> {
-    #[doc = "Calls [VisitAll`::visit_opt_ident`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<ExprOrSpread>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ident(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Ident as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Vec<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<JSXAttrValue> {
-    #[doc = "Calls [VisitAll`::visit_opt_jsx_attr_value`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Ident> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ident`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_jsx_attr_value(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ident(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <JSXAttrValue as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Ident as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<JSXClosingElement> {
-    #[doc = "Calls [VisitAll`::visit_opt_jsx_closing_element`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<JSXAttrValue> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_jsx_attr_value`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_jsx_closing_element(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_jsx_attr_value(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <JSXClosingElement as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <JSXAttrValue as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ModuleExportName> {
-    #[doc = "Calls [VisitAll`::visit_opt_module_export_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<JSXClosingElement> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_jsx_closing_element`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_module_export_name(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_jsx_closing_element(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <ModuleExportName as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <JSXClosingElement as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ObjectLit>> {
-    #[doc = "Calls [VisitAll`::visit_opt_object_lit`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ModuleExportName> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_module_export_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_object_lit(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_module_export_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<ObjectLit> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <ModuleExportName as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Pat> {
-    #[doc = "Calls [VisitAll`::visit_opt_pat`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ObjectLit>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_object_lit`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_pat(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_object_lit(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Pat as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<ObjectLit> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_common::Span> {
-    #[doc = "Calls [VisitAll`::visit_opt_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Pat> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_pat`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_span(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_pat(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_common::Span as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Pat as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Stmt>> {
-    #[doc = "Calls [VisitAll`::visit_opt_stmt`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_common::Span> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_stmt(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Stmt> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <swc_common::Span as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Str>> {
-    #[doc = "Calls [VisitAll`::visit_opt_str`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Stmt>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_stmt`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_str(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_stmt(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<Str> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<Stmt> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TruePlusMinus> {
-    #[doc = "Calls [VisitAll`::visit_opt_true_plus_minus`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Str>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_str`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_true_plus_minus(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_str(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <TruePlusMinus as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<Str> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TsEntityName> {
-    #[doc = "Calls [VisitAll`::visit_opt_ts_entity_name`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TruePlusMinus> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_true_plus_minus`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ts_entity_name(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_true_plus_minus(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <TsEntityName as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <TruePlusMinus as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TsNamespaceBody> {
-    #[doc = "Calls [VisitAll`::visit_opt_ts_namespace_body`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TsEntityName> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ts_entity_name`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ts_namespace_body(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ts_entity_name(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <TsNamespaceBody as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <TsEntityName as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsType>> {
-    #[doc = "Calls [VisitAll`::visit_opt_ts_type`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TsNamespaceBody> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ts_namespace_body`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ts_type(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ts_namespace_body(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TsType> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <TsNamespaceBody as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeAnn>> {
-    #[doc = "Calls [VisitAll`::visit_opt_ts_type_ann`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsType>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ts_type_ann(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ts_type(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TsTypeAnn> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeParamDecl>> {
-    #[doc = "Calls [VisitAll`::visit_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeAnn>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type_ann`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ts_type_param_decl(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ts_type_ann(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Box<TsTypeParamDecl> as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<TsTypeAnn> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeParamInstantiation>> {
-    #[doc = "Calls [VisitAll`::visit_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeParamDecl>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type_param_decl`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_ts_type_param_instantiation(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ts_type_param_decl(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => {
-                <Box<TsTypeParamInstantiation> as VisitAllWith<V>>::visit_with(inner, visitor)
-            }
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<TsTypeParamDecl> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<VarDeclOrExpr> {
-    #[doc = "Calls [VisitAll`::visit_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeParamInstantiation>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_var_decl_or_expr(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_ts_type_param_instantiation(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <VarDeclOrExpr as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <Box<TsTypeParamInstantiation> as FoldWithAstPath<V>>::fold_with_ast_path(
+                inner, visitor, __ast_path,
+            )
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Option<ExprOrSpread>] {
-    #[doc = "Calls [VisitAll`::visit_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<VarDeclOrExpr> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_vec_expr_or_spreads(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_var_decl_or_expr(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Option<ExprOrSpread> as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.map(|inner| {
+            <VarDeclOrExpr as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Option<Pat>] {
-    #[doc = "Calls [VisitAll`::visit_opt_vec_pats`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Option<ExprOrSpread>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_vec_pats(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_vec_expr_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Option<Pat> as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Option<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ParamOrTsParamProp] {
-    #[doc = "Calls [VisitAll`::visit_param_or_ts_param_props`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Option<Pat>> {
+    #[doc = "Calls [FoldAstPath`::fold_opt_vec_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_param_or_ts_param_props(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_opt_vec_pats(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <ParamOrTsParamProp as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Param] {
-    #[doc = "Calls [VisitAll`::visit_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ParamOrTsParamProp> {
+    #[doc = "Calls [FoldAstPath`::fold_param_or_ts_param_props`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_params(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_param_or_ts_param_props(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Param as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <ParamOrTsParamProp as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Pat] {
-    #[doc = "Calls [VisitAll`::visit_pats`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Param> {
+    #[doc = "Calls [FoldAstPath`::fold_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_pats(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Pat as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Param as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PropOrSpread] {
-    #[doc = "Calls [VisitAll`::visit_prop_or_spreads`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Pat> {
+    #[doc = "Calls [FoldAstPath`::fold_pats`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_prop_or_spreads(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_pats(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <PropOrSpread as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Pat as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_common::Span {
-    #[doc = "Calls [VisitAll`::visit_span`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PropOrSpread> {
+    #[doc = "Calls [FoldAstPath`::fold_prop_or_spreads`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_span(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_prop_or_spreads(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <PropOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Stmt] {
-    #[doc = "Calls [VisitAll`::visit_stmts`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::Span {
+    #[doc = "Calls [FoldAstPath`::fold_span`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_stmts(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Stmt as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SwitchCase] {
-    #[doc = "Calls [VisitAll`::visit_switch_cases`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Stmt> {
+    #[doc = "Calls [FoldAstPath`::fold_stmts`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_switch_cases(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_stmts(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <SwitchCase as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Stmt as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, &mut *__ast_path)
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_common::SyntaxContext {
-    #[doc = "Calls [VisitAll`::visit_syntax_context`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SwitchCase> {
+    #[doc = "Calls [FoldAstPath`::fold_switch_cases`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_syntax_context(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_switch_cases(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <SwitchCase as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TplElement] {
-    #[doc = "Calls [VisitAll`::visit_tpl_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::SyntaxContext {
+    #[doc = "Calls [FoldAstPath`::fold_syntax_context`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_tpl_elements(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_syntax_context(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TplElement as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsEnumMember] {
-    #[doc = "Calls [VisitAll`::visit_ts_enum_members`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TplElement> {
+    #[doc = "Calls [FoldAstPath`::fold_tpl_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_enum_members(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_tpl_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsEnumMember as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <TplElement as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsExprWithTypeArgs] {
-    #[doc = "Calls [VisitAll`::visit_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsEnumMember> {
+    #[doc = "Calls [FoldAstPath`::fold_ts_enum_members`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_expr_with_type_argss(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_enum_members(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsExprWithTypeArgs as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <TsEnumMember as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsFnParam] {
-    #[doc = "Calls [VisitAll`::visit_ts_fn_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsExprWithTypeArgs> {
+    #[doc = "Calls [FoldAstPath`::fold_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_fn_params(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_expr_with_type_argss(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsFnParam as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <TsExprWithTypeArgs as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTupleElement] {
-    #[doc = "Calls [VisitAll`::visit_ts_tuple_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsFnParam> {
+    #[doc = "Calls [FoldAstPath`::fold_ts_fn_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_tuple_elements(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_fn_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsTupleElement as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <TsFnParam as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTypeElement] {
-    #[doc = "Calls [VisitAll`::visit_ts_type_elements`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTupleElement> {
+    #[doc = "Calls [FoldAstPath`::fold_ts_tuple_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_elements(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_tuple_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsTypeElement as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <TsTupleElement as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTypeParam] {
-    #[doc = "Calls [VisitAll`::visit_ts_type_params`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTypeElement> {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_elements`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_type_params(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_elements(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <TsTypeParam as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <TsTypeElement as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Box<TsType>] {
-    #[doc = "Calls [VisitAll`::visit_ts_types`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTypeParam> {
+    #[doc = "Calls [FoldAstPath`::fold_ts_type_params`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_ts_types(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_type_params(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Box<TsType> as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <TsTypeParam as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [VarDeclarator] {
-    #[doc = "Calls [VisitAll`::visit_var_declarators`] with `self`. (Extra impl)"]
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Box<TsType>> {
+    #[doc = "Calls [FoldAstPath`::fold_ts_types`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_var_declarators(visitor, self)
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_ts_types(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <VarDeclarator as VisitAllWith<V>>::visit_with(item, visitor))
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V, T> VisitAllWith<V> for std::boxed::Box<T>
-where
-    V: ?Sized + VisitAll,
-    T: VisitAllWith<V>,
-{
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<VarDeclarator> {
+    #[doc = "Calls [FoldAstPath`::fold_var_declarators`] with `self`. (Extra impl)"]
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_with(&**self, visitor);
-        v
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        <V as FoldAstPath>::fold_var_declarators(visitor, self, __ast_path)
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_children_with(&**self, visitor);
-        v
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        self.into_iter()
+            .enumerate()
+            .map(|(__idx, item)| {
+                let mut __ast_path = __ast_path.with_index_guard(__idx);
+                <VarDeclarator as FoldWithAstPath<V>>::fold_with_ast_path(
+                    item,
+                    visitor,
+                    &mut *__ast_path,
+                )
+            })
+            .collect()
     }
 }
-impl<V, T> VisitAllWith<V> for std::vec::Vec<T>
+#[cfg(any(docsrs, feature = "path"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
+impl<V, T> FoldWithAstPath<V> for std::boxed::Box<T>
 where
-    V: ?Sized + VisitAll,
-    [T]: VisitAllWith<V>,
+    V: ?Sized + FoldAstPath,
+    T: FoldWithAstPath<V>,
 {
     #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_with(self, visitor);
-        v
+    fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        swc_visit::util::map::Map::map(self, |inner| {
+            <T as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 
     #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_children_with(self, visitor);
-        v
+    fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
+        swc_visit::util::map::Map::map(self, |inner| {
+            <T as FoldWithAstPath<V>>::fold_children_with_ast_path(inner, visitor, __ast_path)
+        })
     }
 }
 #[cfg(any(docsrs, feature = "path"))]
diff --git a/crates/swc_html_visit/src/generated.rs b/crates/swc_html_visit/src/generated.rs
index bb355b2657ba..e27acacf5abe 100644
--- a/crates/swc_html_visit/src/generated.rs
+++ b/crates/swc_html_visit/src/generated.rs
@@ -776,148 +776,6 @@ where
         }
     }
 }
-impl<V> Visit for ::swc_visit::All<V>
-where
-    V: VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut self.visitor, node);
-        <swc_atoms::Atom as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <V as VisitAll>::visit_attribute(&mut self.visitor, node);
-        <Attribute as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <V as VisitAll>::visit_attribute_token(&mut self.visitor, node);
-        <AttributeToken as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <V as VisitAll>::visit_attribute_tokens(&mut self.visitor, node);
-        <[AttributeToken] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <V as VisitAll>::visit_attributes(&mut self.visitor, node);
-        <[Attribute] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <V as VisitAll>::visit_child(&mut self.visitor, node);
-        <Child as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <V as VisitAll>::visit_childs(&mut self.visitor, node);
-        <[Child] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <V as VisitAll>::visit_comment(&mut self.visitor, node);
-        <Comment as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <V as VisitAll>::visit_document(&mut self.visitor, node);
-        <Document as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_fragment(&mut self, node: &DocumentFragment) {
-        <V as VisitAll>::visit_document_fragment(&mut self.visitor, node);
-        <DocumentFragment as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <V as VisitAll>::visit_document_mode(&mut self.visitor, node);
-        <DocumentMode as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <V as VisitAll>::visit_document_type(&mut self.visitor, node);
-        <DocumentType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <V as VisitAll>::visit_element(&mut self.visitor, node);
-        <Element as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut self.visitor, node);
-        <Namespace as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut self.visitor, node);
-        <Option<swc_atoms::Atom> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_document_fragment(&mut self, node: &Option<DocumentFragment>) {
-        <V as VisitAll>::visit_opt_document_fragment(&mut self.visitor, node);
-        <Option<DocumentFragment> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut self.visitor, node);
-        <Option<Namespace> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_raw(&mut self, node: &Option<Raw>) {
-        <V as VisitAll>::visit_opt_raw(&mut self.visitor, node);
-        <Option<Raw> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_raw(&mut self, node: &Raw) {
-        <V as VisitAll>::visit_raw(&mut self.visitor, node);
-        <Raw as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut self.visitor, node);
-        <swc_common::Span as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <V as VisitAll>::visit_text(&mut self.visitor, node);
-        <Text as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut self.visitor, node);
-        <Token as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut self.visitor, node);
-        <TokenAndSpan as VisitWith<Self>>::visit_children_with(node, self);
-    }
-}
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
 pub trait VisitWith<V: ?Sized + Visit> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
@@ -2762,9 +2620,6 @@ where
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for ::swc_visit::All<V> where V: VisitAll {}
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
 #[cfg(any(docsrs, feature = "path"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
@@ -10954,1358 +10809,6 @@ where
         })
     }
 }
-#[doc = r" A visitor trait for traversing the AST."]
-pub trait VisitAll {
-    #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <swc_atoms::Atom as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
-             [`Attribute::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <Attribute as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
-             [`AttributeToken::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <AttributeToken as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
-             < AttributeToken >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <[AttributeToken] as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
-             Attribute >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <[Attribute] as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
-             [`Child::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <Child as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <[Child] as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
-             [`Comment::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <Comment as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
-             [`Document::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <Document as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `DocumentFragment`.\n\nBy default, this method calls \
-             [`DocumentFragment::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_document_fragment(&mut self, node: &DocumentFragment) {
-        <DocumentFragment as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
-             [`DocumentMode::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <DocumentMode as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
-             [`DocumentType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <DocumentType as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
-             [`Element::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <Element as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <Namespace as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <Option<swc_atoms::Atom> as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < DocumentFragment >`.\n\nBy default, this method calls \
-             [`Option < DocumentFragment >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
-    #[inline]
-    fn visit_opt_document_fragment(&mut self, node: &Option<DocumentFragment>) {
-        <Option<DocumentFragment> as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <Option<Namespace> as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Raw >`.\n\nBy default, this method calls [`Option < \
-             Raw >::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_opt_raw(&mut self, node: &Option<Raw>) {
-        <Option<Raw> as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Raw`.\n\nBy default, this method calls \
-             [`Raw::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_raw(&mut self, node: &Raw) {
-        <Raw as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <swc_common::Span as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
-             [`Text::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <Text as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <Token as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <TokenAndSpan as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-}
-impl<V> VisitAll for &mut V
-where
-    V: ?Sized + VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <V as VisitAll>::visit_attribute(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <V as VisitAll>::visit_attribute_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <V as VisitAll>::visit_attribute_tokens(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <V as VisitAll>::visit_attributes(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <V as VisitAll>::visit_child(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <V as VisitAll>::visit_childs(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <V as VisitAll>::visit_comment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <V as VisitAll>::visit_document(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_fragment(&mut self, node: &DocumentFragment) {
-        <V as VisitAll>::visit_document_fragment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <V as VisitAll>::visit_document_mode(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <V as VisitAll>::visit_document_type(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <V as VisitAll>::visit_element(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_document_fragment(&mut self, node: &Option<DocumentFragment>) {
-        <V as VisitAll>::visit_opt_document_fragment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_raw(&mut self, node: &Option<Raw>) {
-        <V as VisitAll>::visit_opt_raw(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_raw(&mut self, node: &Raw) {
-        <V as VisitAll>::visit_raw(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <V as VisitAll>::visit_text(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut **self, node)
-    }
-}
-impl<V> VisitAll for Box<V>
-where
-    V: ?Sized + VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <V as VisitAll>::visit_attribute(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <V as VisitAll>::visit_attribute_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <V as VisitAll>::visit_attribute_tokens(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <V as VisitAll>::visit_attributes(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <V as VisitAll>::visit_child(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <V as VisitAll>::visit_childs(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <V as VisitAll>::visit_comment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <V as VisitAll>::visit_document(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_fragment(&mut self, node: &DocumentFragment) {
-        <V as VisitAll>::visit_document_fragment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <V as VisitAll>::visit_document_mode(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <V as VisitAll>::visit_document_type(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <V as VisitAll>::visit_element(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_document_fragment(&mut self, node: &Option<DocumentFragment>) {
-        <V as VisitAll>::visit_opt_document_fragment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_raw(&mut self, node: &Option<Raw>) {
-        <V as VisitAll>::visit_opt_raw(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_raw(&mut self, node: &Raw) {
-        <V as VisitAll>::visit_raw(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <V as VisitAll>::visit_text(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut **self, node)
-    }
-}
-impl<A, B> VisitAll for ::swc_visit::Either<A, B>
-where
-    A: VisitAll,
-    B: VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_atom(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attribute(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attribute(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attribute_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attribute_token(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attribute_tokens(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attribute_tokens(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attributes(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attributes(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_child(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_child(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_childs(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_childs(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_comment(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_comment(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_document_fragment(&mut self, node: &DocumentFragment) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document_fragment(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document_fragment(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document_mode(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document_mode(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document_type(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_element(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_namespace(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_atom(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_opt_document_fragment(&mut self, node: &Option<DocumentFragment>) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_opt_document_fragment(visitor, node)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_opt_document_fragment(visitor, node)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_namespace(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_opt_raw(&mut self, node: &Option<Raw>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_raw(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_raw(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_raw(&mut self, node: &Raw) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_raw(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_raw(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_span(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_text(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_text(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_token(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_token_and_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_token_and_span(visitor, node),
-        }
-    }
-}
-impl<V> VisitAll for ::swc_visit::Optional<V>
-where
-    V: VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        if self.enabled {
-            <V as VisitAll>::visit_atom(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        if self.enabled {
-            <V as VisitAll>::visit_attribute(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        if self.enabled {
-            <V as VisitAll>::visit_attribute_token(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        if self.enabled {
-            <V as VisitAll>::visit_attribute_tokens(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        if self.enabled {
-            <V as VisitAll>::visit_attributes(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        if self.enabled {
-            <V as VisitAll>::visit_child(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        if self.enabled {
-            <V as VisitAll>::visit_childs(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        if self.enabled {
-            <V as VisitAll>::visit_comment(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        if self.enabled {
-            <V as VisitAll>::visit_document(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_fragment(&mut self, node: &DocumentFragment) {
-        if self.enabled {
-            <V as VisitAll>::visit_document_fragment(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        if self.enabled {
-            <V as VisitAll>::visit_document_mode(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        if self.enabled {
-            <V as VisitAll>::visit_document_type(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        if self.enabled {
-            <V as VisitAll>::visit_element(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        if self.enabled {
-            <V as VisitAll>::visit_namespace(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        if self.enabled {
-            <V as VisitAll>::visit_opt_atom(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_document_fragment(&mut self, node: &Option<DocumentFragment>) {
-        if self.enabled {
-            <V as VisitAll>::visit_opt_document_fragment(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        if self.enabled {
-            <V as VisitAll>::visit_opt_namespace(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_raw(&mut self, node: &Option<Raw>) {
-        if self.enabled {
-            <V as VisitAll>::visit_opt_raw(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_raw(&mut self, node: &Raw) {
-        if self.enabled {
-            <V as VisitAll>::visit_raw(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        if self.enabled {
-            <V as VisitAll>::visit_span(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        if self.enabled {
-            <V as VisitAll>::visit_text(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        if self.enabled {
-            <V as VisitAll>::visit_token(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        if self.enabled {
-            <V as VisitAll>::visit_token_and_span(&mut self.visitor, node)
-        } else {
-        }
-    }
-}
-#[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitAllWith<V: ?Sized + VisitAll> {
-    #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with(&self, visitor: &mut V);
-    #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with(&self, visitor: &mut V);
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Attribute {
-    #[doc = "Calls [VisitAll`::visit_attribute`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Attribute {
-                span,
-                namespace,
-                prefix,
-                name,
-                raw_name,
-                value,
-                raw_value,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Namespace> as VisitAllWith<V>>::visit_with(namespace, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(prefix, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeToken {
-    #[doc = "Calls [VisitAll`::visit_attribute_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_token(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AttributeToken {
-                span,
-                name,
-                raw_name,
-                value,
-                raw_value,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Child {
-    #[doc = "Calls [VisitAll`::visit_child`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_child(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Child::DocumentType { 0: _field_0 } => {
-                <DocumentType as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::Element { 0: _field_0 } => {
-                <Element as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::Text { 0: _field_0 } => {
-                <Text as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::Comment { 0: _field_0 } => {
-                <Comment as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Comment {
-    #[doc = "Calls [VisitAll`::visit_comment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_comment(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Comment { span, data, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Document {
-    #[doc = "Calls [VisitAll`::visit_document`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Document {
-                span,
-                mode,
-                children,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <DocumentMode as VisitAllWith<V>>::visit_with(mode, visitor)
-                };
-                {
-                    <Vec<Child> as VisitAllWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DocumentFragment {
-    #[doc = "Calls [VisitAll`::visit_document_fragment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_fragment(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DocumentFragment { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Child> as VisitAllWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DocumentMode {
-    #[doc = "Calls [VisitAll`::visit_document_mode`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_mode(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DocumentMode::NoQuirks => {}
-            DocumentMode::LimitedQuirks => {}
-            DocumentMode::Quirks => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DocumentType {
-    #[doc = "Calls [VisitAll`::visit_document_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DocumentType {
-                span,
-                name,
-                public_id,
-                system_id,
-                raw,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(public_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(system_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Element {
-    #[doc = "Calls [VisitAll`::visit_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Element {
-                span,
-                tag_name,
-                namespace,
-                attributes,
-                children,
-                content,
-                is_self_closing,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(tag_name, visitor)
-                };
-                {
-                    <Namespace as VisitAllWith<V>>::visit_with(namespace, visitor)
-                };
-                {
-                    <Vec<Attribute> as VisitAllWith<V>>::visit_with(attributes, visitor)
-                };
-                {
-                    <Vec<Child> as VisitAllWith<V>>::visit_with(children, visitor)
-                };
-                {
-                    <Option<DocumentFragment> as VisitAllWith<V>>::visit_with(content, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Namespace {
-    #[doc = "Calls [VisitAll`::visit_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_namespace(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Namespace::HTML => {}
-            Namespace::MATHML => {}
-            Namespace::SVG => {}
-            Namespace::XLINK => {}
-            Namespace::XML => {}
-            Namespace::XMLNS => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Raw {
-    #[doc = "Calls [VisitAll`::visit_raw`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_raw(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Raw::Same => {}
-            Raw::Atom { 0: _field_0 } => {
-                <swc_atoms::Atom as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Text {
-    #[doc = "Calls [VisitAll`::visit_text`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_text(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Text { span, data, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Token {
-    #[doc = "Calls [VisitAll`::visit_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_token(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Token::Doctype {
-                name,
-                force_quirks,
-                public_id,
-                system_id,
-                raw,
-            } => {
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(public_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(system_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::StartTag {
-                tag_name,
-                raw_tag_name,
-                is_self_closing,
-                attributes,
-            } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(tag_name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_tag_name, visitor)
-                };
-                {
-                    <Vec<AttributeToken> as VisitAllWith<V>>::visit_with(attributes, visitor)
-                };
-            }
-            Token::EndTag {
-                tag_name,
-                raw_tag_name,
-                is_self_closing,
-                attributes,
-            } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(tag_name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_tag_name, visitor)
-                };
-                {
-                    <Vec<AttributeToken> as VisitAllWith<V>>::visit_with(attributes, visitor)
-                };
-            }
-            Token::Comment { data, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Character { value, raw } => {
-                {
-                    <Option<Raw> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Eof => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TokenAndSpan {
-    #[doc = "Calls [VisitAll`::visit_token_and_span`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_token_and_span(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TokenAndSpan { span, token } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Token as VisitAllWith<V>>::visit_with(token, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitAll`::visit_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [AttributeToken] {
-    #[doc = "Calls [VisitAll`::visit_attribute_tokens`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_tokens(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <AttributeToken as VisitAllWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Attribute] {
-    #[doc = "Calls [VisitAll`::visit_attributes`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attributes(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Attribute as VisitAllWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Child] {
-    #[doc = "Calls [VisitAll`::visit_childs`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_childs(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Child as VisitAllWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitAll`::visit_opt_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_atoms::Atom as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<DocumentFragment> {
-    #[doc = "Calls [VisitAll`::visit_opt_document_fragment`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_document_fragment(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <DocumentFragment as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Namespace> {
-    #[doc = "Calls [VisitAll`::visit_opt_namespace`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_namespace(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Namespace as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Raw> {
-    #[doc = "Calls [VisitAll`::visit_opt_raw`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_raw(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Raw as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_common::Span {
-    #[doc = "Calls [VisitAll`::visit_span`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_span(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V, T> VisitAllWith<V> for std::boxed::Box<T>
-where
-    V: ?Sized + VisitAll,
-    T: VisitAllWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_with(&**self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_children_with(&**self, visitor);
-        v
-    }
-}
-impl<V, T> VisitAllWith<V> for std::vec::Vec<T>
-where
-    V: ?Sized + VisitAll,
-    [T]: VisitAllWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_with(self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_children_with(self, visitor);
-        v
-    }
-}
 #[cfg(any(docsrs, feature = "path"))]
 pub type AstKindPath = swc_visit::AstKindPath<AstParentKind>;
 #[cfg(any(docsrs, feature = "path"))]
diff --git a/crates/swc_xml_visit/src/generated.rs b/crates/swc_xml_visit/src/generated.rs
index b5a6395da32f..7e90b040ad2b 100644
--- a/crates/swc_xml_visit/src/generated.rs
+++ b/crates/swc_xml_visit/src/generated.rs
@@ -712,136 +712,6 @@ where
         }
     }
 }
-impl<V> Visit for ::swc_visit::All<V>
-where
-    V: VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut self.visitor, node);
-        <swc_atoms::Atom as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <V as VisitAll>::visit_attribute(&mut self.visitor, node);
-        <Attribute as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <V as VisitAll>::visit_attribute_token(&mut self.visitor, node);
-        <AttributeToken as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <V as VisitAll>::visit_attribute_tokens(&mut self.visitor, node);
-        <[AttributeToken] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <V as VisitAll>::visit_attributes(&mut self.visitor, node);
-        <[Attribute] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_cdata_section(&mut self, node: &CdataSection) {
-        <V as VisitAll>::visit_cdata_section(&mut self.visitor, node);
-        <CdataSection as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <V as VisitAll>::visit_child(&mut self.visitor, node);
-        <Child as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <V as VisitAll>::visit_childs(&mut self.visitor, node);
-        <[Child] as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <V as VisitAll>::visit_comment(&mut self.visitor, node);
-        <Comment as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <V as VisitAll>::visit_document(&mut self.visitor, node);
-        <Document as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <V as VisitAll>::visit_document_mode(&mut self.visitor, node);
-        <DocumentMode as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <V as VisitAll>::visit_document_type(&mut self.visitor, node);
-        <DocumentType as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <V as VisitAll>::visit_element(&mut self.visitor, node);
-        <Element as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut self.visitor, node);
-        <Namespace as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut self.visitor, node);
-        <Option<swc_atoms::Atom> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut self.visitor, node);
-        <Option<Namespace> as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_processing_instruction(&mut self, node: &ProcessingInstruction) {
-        <V as VisitAll>::visit_processing_instruction(&mut self.visitor, node);
-        <ProcessingInstruction as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut self.visitor, node);
-        <swc_common::Span as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <V as VisitAll>::visit_text(&mut self.visitor, node);
-        <Text as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut self.visitor, node);
-        <Token as VisitWith<Self>>::visit_children_with(node, self);
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut self.visitor, node);
-        <TokenAndSpan as VisitWith<Self>>::visit_children_with(node, self);
-    }
-}
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
 pub trait VisitWith<V: ?Sized + Visit> {
     #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
@@ -2580,9 +2450,6 @@ where
         }
     }
 }
-#[cfg(any(docsrs, feature = "path"))]
-#[cfg_attr(docsrs, doc(cfg(feature = "path")))]
-impl<V> VisitAstPath for ::swc_visit::All<V> where V: VisitAll {}
 #[doc = r" A trait implemented for types that can be visited using a visitor."]
 #[cfg(any(docsrs, feature = "path"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
@@ -10507,1277 +10374,6 @@ where
         })
     }
 }
-#[doc = r" A visitor trait for traversing the AST."]
-pub trait VisitAll {
-    #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
-             [`swc_atoms :: Atom::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <swc_atoms::Atom as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
-             [`Attribute::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <Attribute as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
-             [`AttributeToken::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <AttributeToken as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
-             < AttributeToken >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <[AttributeToken] as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
-             Attribute >::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <[Attribute] as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `CdataSection`.\n\nBy default, this method calls \
-             [`CdataSection::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_cdata_section(&mut self, node: &CdataSection) {
-        <CdataSection as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
-             [`Child::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <Child as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
-             >::visit_children_with`]. This method unconditionally calls the visitor method for \
-             all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <[Child] as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
-             [`Comment::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <Comment as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
-             [`Document::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <Document as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
-             [`DocumentMode::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <DocumentMode as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
-             [`DocumentType::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <DocumentType as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
-             [`Element::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <Element as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
-             [`Namespace::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <Namespace as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < swc_atoms :: Atom >`.\n\nBy default, this method calls \
-             [`Option < swc_atoms :: Atom >::visit_children_with`]. This method unconditionally \
-             calls the visitor method for all children because it's defined in the trait \
-             [VisitAll]."]
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <Option<swc_atoms::Atom> as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Option < Namespace >`.\n\nBy default, this method calls \
-             [`Option < Namespace >::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <Option<Namespace> as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `ProcessingInstruction`.\n\nBy default, this method calls \
-             [`ProcessingInstruction::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_processing_instruction(&mut self, node: &ProcessingInstruction) {
-        <ProcessingInstruction as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `swc_common :: Span`.\n\nBy default, this method calls \
-             [`swc_common :: Span::visit_children_with`]. This method unconditionally calls the \
-             visitor method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <swc_common::Span as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
-             [`Text::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <Text as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
-             [`Token::visit_children_with`]. This method unconditionally calls the visitor method \
-             for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <Token as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-    #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
-             [`TokenAndSpan::visit_children_with`]. This method unconditionally calls the visitor \
-             method for all children because it's defined in the trait [VisitAll]."]
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <TokenAndSpan as VisitAllWith<Self>>::visit_children_with(node, self)
-    }
-}
-impl<V> VisitAll for &mut V
-where
-    V: ?Sized + VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <V as VisitAll>::visit_attribute(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <V as VisitAll>::visit_attribute_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <V as VisitAll>::visit_attribute_tokens(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <V as VisitAll>::visit_attributes(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_cdata_section(&mut self, node: &CdataSection) {
-        <V as VisitAll>::visit_cdata_section(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <V as VisitAll>::visit_child(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <V as VisitAll>::visit_childs(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <V as VisitAll>::visit_comment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <V as VisitAll>::visit_document(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <V as VisitAll>::visit_document_mode(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <V as VisitAll>::visit_document_type(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <V as VisitAll>::visit_element(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_processing_instruction(&mut self, node: &ProcessingInstruction) {
-        <V as VisitAll>::visit_processing_instruction(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <V as VisitAll>::visit_text(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut **self, node)
-    }
-}
-impl<V> VisitAll for Box<V>
-where
-    V: ?Sized + VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        <V as VisitAll>::visit_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        <V as VisitAll>::visit_attribute(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        <V as VisitAll>::visit_attribute_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        <V as VisitAll>::visit_attribute_tokens(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        <V as VisitAll>::visit_attributes(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_cdata_section(&mut self, node: &CdataSection) {
-        <V as VisitAll>::visit_cdata_section(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        <V as VisitAll>::visit_child(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        <V as VisitAll>::visit_childs(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        <V as VisitAll>::visit_comment(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        <V as VisitAll>::visit_document(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        <V as VisitAll>::visit_document_mode(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        <V as VisitAll>::visit_document_type(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        <V as VisitAll>::visit_element(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        <V as VisitAll>::visit_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        <V as VisitAll>::visit_opt_atom(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        <V as VisitAll>::visit_opt_namespace(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_processing_instruction(&mut self, node: &ProcessingInstruction) {
-        <V as VisitAll>::visit_processing_instruction(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        <V as VisitAll>::visit_span(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        <V as VisitAll>::visit_text(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        <V as VisitAll>::visit_token(&mut **self, node)
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        <V as VisitAll>::visit_token_and_span(&mut **self, node)
-    }
-}
-impl<A, B> VisitAll for ::swc_visit::Either<A, B>
-where
-    A: VisitAll,
-    B: VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_atom(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attribute(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attribute(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attribute_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attribute_token(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attribute_tokens(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attribute_tokens(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_attributes(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_attributes(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_cdata_section(&mut self, node: &CdataSection) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_cdata_section(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_cdata_section(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_child(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_child(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_childs(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_childs(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_comment(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_comment(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document_mode(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document_mode(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_document_type(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_document_type(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_element(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_element(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_namespace(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_atom(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_atom(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_opt_namespace(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_opt_namespace(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_processing_instruction(&mut self, node: &ProcessingInstruction) {
-        match self {
-            swc_visit::Either::Left(visitor) => {
-                VisitAll::visit_processing_instruction(visitor, node)
-            }
-            swc_visit::Either::Right(visitor) => {
-                VisitAll::visit_processing_instruction(visitor, node)
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_span(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_text(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_text(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_token(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_token(visitor, node),
-        }
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        match self {
-            swc_visit::Either::Left(visitor) => VisitAll::visit_token_and_span(visitor, node),
-            swc_visit::Either::Right(visitor) => VisitAll::visit_token_and_span(visitor, node),
-        }
-    }
-}
-impl<V> VisitAll for ::swc_visit::Optional<V>
-where
-    V: VisitAll,
-{
-    #[inline]
-    fn visit_atom(&mut self, node: &swc_atoms::Atom) {
-        if self.enabled {
-            <V as VisitAll>::visit_atom(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute(&mut self, node: &Attribute) {
-        if self.enabled {
-            <V as VisitAll>::visit_attribute(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_token(&mut self, node: &AttributeToken) {
-        if self.enabled {
-            <V as VisitAll>::visit_attribute_token(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
-        if self.enabled {
-            <V as VisitAll>::visit_attribute_tokens(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_attributes(&mut self, node: &[Attribute]) {
-        if self.enabled {
-            <V as VisitAll>::visit_attributes(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_cdata_section(&mut self, node: &CdataSection) {
-        if self.enabled {
-            <V as VisitAll>::visit_cdata_section(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_child(&mut self, node: &Child) {
-        if self.enabled {
-            <V as VisitAll>::visit_child(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_childs(&mut self, node: &[Child]) {
-        if self.enabled {
-            <V as VisitAll>::visit_childs(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_comment(&mut self, node: &Comment) {
-        if self.enabled {
-            <V as VisitAll>::visit_comment(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document(&mut self, node: &Document) {
-        if self.enabled {
-            <V as VisitAll>::visit_document(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_mode(&mut self, node: &DocumentMode) {
-        if self.enabled {
-            <V as VisitAll>::visit_document_mode(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_document_type(&mut self, node: &DocumentType) {
-        if self.enabled {
-            <V as VisitAll>::visit_document_type(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_element(&mut self, node: &Element) {
-        if self.enabled {
-            <V as VisitAll>::visit_element(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_namespace(&mut self, node: &Namespace) {
-        if self.enabled {
-            <V as VisitAll>::visit_namespace(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_atom(&mut self, node: &Option<swc_atoms::Atom>) {
-        if self.enabled {
-            <V as VisitAll>::visit_opt_atom(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
-        if self.enabled {
-            <V as VisitAll>::visit_opt_namespace(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_processing_instruction(&mut self, node: &ProcessingInstruction) {
-        if self.enabled {
-            <V as VisitAll>::visit_processing_instruction(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_span(&mut self, node: &swc_common::Span) {
-        if self.enabled {
-            <V as VisitAll>::visit_span(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_text(&mut self, node: &Text) {
-        if self.enabled {
-            <V as VisitAll>::visit_text(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_token(&mut self, node: &Token) {
-        if self.enabled {
-            <V as VisitAll>::visit_token(&mut self.visitor, node)
-        } else {
-        }
-    }
-
-    #[inline]
-    fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
-        if self.enabled {
-            <V as VisitAll>::visit_token_and_span(&mut self.visitor, node)
-        } else {
-        }
-    }
-}
-#[doc = r" A trait implemented for types that can be visited using a visitor."]
-pub trait VisitAllWith<V: ?Sized + VisitAll> {
-    #[doc = r" Calls a visitor method (visitor.fold_xxx) with self."]
-    fn visit_with(&self, visitor: &mut V);
-    #[doc = r" Visit children nodes of `self`` with `visitor`."]
-    fn visit_children_with(&self, visitor: &mut V);
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Attribute {
-    #[doc = "Calls [VisitAll`::visit_attribute`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Attribute {
-                span,
-                namespace,
-                prefix,
-                name,
-                raw_name,
-                value,
-                raw_value,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<Namespace> as VisitAllWith<V>>::visit_with(namespace, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(prefix, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for AttributeToken {
-    #[doc = "Calls [VisitAll`::visit_attribute_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_token(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            AttributeToken {
-                span,
-                name,
-                raw_name,
-                value,
-                raw_value,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(value, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw_value, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for CdataSection {
-    #[doc = "Calls [VisitAll`::visit_cdata_section`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_cdata_section(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            CdataSection { span, data, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Child {
-    #[doc = "Calls [VisitAll`::visit_child`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_child(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Child::DocumentType { 0: _field_0 } => {
-                <DocumentType as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::Element { 0: _field_0 } => {
-                <Element as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::Text { 0: _field_0 } => {
-                <Text as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::CdataSection { 0: _field_0 } => {
-                <CdataSection as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::Comment { 0: _field_0 } => {
-                <Comment as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-            Child::ProcessingInstruction { 0: _field_0 } => {
-                <ProcessingInstruction as VisitAllWith<V>>::visit_with(_field_0, visitor);
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Comment {
-    #[doc = "Calls [VisitAll`::visit_comment`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_comment(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Comment { span, data, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Document {
-    #[doc = "Calls [VisitAll`::visit_document`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Document { span, children } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Vec<Child> as VisitAllWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DocumentMode {
-    #[doc = "Calls [VisitAll`::visit_document_mode`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_mode(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DocumentMode::NoQuirks => {}
-            DocumentMode::LimitedQuirks => {}
-            DocumentMode::Quirks => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for DocumentType {
-    #[doc = "Calls [VisitAll`::visit_document_type`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_document_type(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            DocumentType {
-                span,
-                name,
-                public_id,
-                system_id,
-                raw,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(public_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(system_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Element {
-    #[doc = "Calls [VisitAll`::visit_element`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_element(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Element {
-                span,
-                tag_name,
-                attributes,
-                children,
-            } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(tag_name, visitor)
-                };
-                {
-                    <Vec<Attribute> as VisitAllWith<V>>::visit_with(attributes, visitor)
-                };
-                {
-                    <Vec<Child> as VisitAllWith<V>>::visit_with(children, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Namespace {
-    #[doc = "Calls [VisitAll`::visit_namespace`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_namespace(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Namespace::HTML => {}
-            Namespace::MATHML => {}
-            Namespace::SVG => {}
-            Namespace::XLINK => {}
-            Namespace::XML => {}
-            Namespace::XMLNS => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for ProcessingInstruction {
-    #[doc = "Calls [VisitAll`::visit_processing_instruction`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_processing_instruction(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            ProcessingInstruction { span, target, data } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(target, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Text {
-    #[doc = "Calls [VisitAll`::visit_text`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_text(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Text { span, data, raw } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Token {
-    #[doc = "Calls [VisitAll`::visit_token`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_token(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Token::Doctype {
-                name,
-                public_id,
-                system_id,
-                raw,
-            } => {
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(name, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(public_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(system_id, visitor)
-                };
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::StartTag {
-                tag_name,
-                attributes,
-            } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(tag_name, visitor)
-                };
-                {
-                    <Vec<AttributeToken> as VisitAllWith<V>>::visit_with(attributes, visitor)
-                };
-            }
-            Token::EndTag {
-                tag_name,
-                attributes,
-            } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(tag_name, visitor)
-                };
-                {
-                    <Vec<AttributeToken> as VisitAllWith<V>>::visit_with(attributes, visitor)
-                };
-            }
-            Token::EmptyTag {
-                tag_name,
-                attributes,
-            } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(tag_name, visitor)
-                };
-                {
-                    <Vec<AttributeToken> as VisitAllWith<V>>::visit_with(attributes, visitor)
-                };
-            }
-            Token::Comment { data, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Character { value, raw } => {
-                {
-                    <Option<swc_atoms::Atom> as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::ProcessingInstruction { target, data } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(target, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-            }
-            Token::Cdata { data, raw } => {
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(data, visitor)
-                };
-                {
-                    <swc_atoms::Atom as VisitAllWith<V>>::visit_with(raw, visitor)
-                };
-            }
-            Token::Eof => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for TokenAndSpan {
-    #[doc = "Calls [VisitAll`::visit_token_and_span`] with `self`."]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_token_and_span(visitor, self)
-    }
-
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            TokenAndSpan { span, token } => {
-                {
-                    <swc_common::Span as VisitAllWith<V>>::visit_with(span, visitor)
-                };
-                {
-                    <Token as VisitAllWith<V>>::visit_with(token, visitor)
-                };
-            }
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_atoms::Atom {
-    #[doc = "Calls [VisitAll`::visit_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [AttributeToken] {
-    #[doc = "Calls [VisitAll`::visit_attribute_tokens`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attribute_tokens(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <AttributeToken as VisitAllWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Attribute] {
-    #[doc = "Calls [VisitAll`::visit_attributes`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_attributes(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Attribute as VisitAllWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Child] {
-    #[doc = "Calls [VisitAll`::visit_childs`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_childs(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        self.iter()
-            .for_each(|item| <Child as VisitAllWith<V>>::visit_with(item, visitor))
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
-    #[doc = "Calls [VisitAll`::visit_opt_atom`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_atom(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <swc_atoms::Atom as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Namespace> {
-    #[doc = "Calls [VisitAll`::visit_opt_namespace`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_opt_namespace(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        match self {
-            Some(inner) => <Namespace as VisitAllWith<V>>::visit_with(inner, visitor),
-            None => {}
-        }
-    }
-}
-impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_common::Span {
-    #[doc = "Calls [VisitAll`::visit_span`] with `self`. (Extra impl)"]
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        <V as VisitAll>::visit_span(visitor, self)
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        {}
-    }
-}
-impl<V, T> VisitAllWith<V> for std::boxed::Box<T>
-where
-    V: ?Sized + VisitAll,
-    T: VisitAllWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_with(&**self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <T as VisitAllWith<V>>::visit_children_with(&**self, visitor);
-        v
-    }
-}
-impl<V, T> VisitAllWith<V> for std::vec::Vec<T>
-where
-    V: ?Sized + VisitAll,
-    [T]: VisitAllWith<V>,
-{
-    #[inline]
-    fn visit_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_with(self, visitor);
-        v
-    }
-
-    #[inline]
-    fn visit_children_with(&self, visitor: &mut V) {
-        let v = <[T] as VisitAllWith<V>>::visit_children_with(self, visitor);
-        v
-    }
-}
 #[cfg(any(docsrs, feature = "path"))]
 pub type AstKindPath = swc_visit::AstKindPath<AstParentKind>;
 #[cfg(any(docsrs, feature = "path"))]
diff --git a/tools/generate-code/src/generators/visitor.rs b/tools/generate-code/src/generators/visitor.rs
index 750790ef2047..d57f41dcc190 100644
--- a/tools/generate-code/src/generators/visitor.rs
+++ b/tools/generate-code/src/generators/visitor.rs
@@ -57,19 +57,8 @@ pub fn generate(crate_name: &Ident, node_types: &[&Item]) -> File {
         pub use ::swc_visit::All;
     ));
 
-    for &kind in [
-        TraitKind::Visit,
-        TraitKind::VisitMut,
-        TraitKind::Fold,
-        TraitKind::VisitAll,
-    ]
-    .iter()
-    {
+    for &kind in [TraitKind::Visit, TraitKind::VisitMut, TraitKind::Fold].iter() {
         for &variant in [Variant::Normal, Variant::AstPath].iter() {
-            if let (TraitKind::VisitAll, Variant::AstPath) = (kind, variant) {
-                continue;
-            }
-
             let g = Generator { kind, variant };
 
             output.items.extend(g.declare_visit_trait(&all_types));
@@ -256,7 +245,6 @@ fn all_types_in_ty(ty: &Type) -> Vec<FieldType> {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum TraitKind {
     Visit,
-    VisitAll,
     VisitMut,
     Fold,
 }
@@ -265,7 +253,6 @@ impl TraitKind {
     pub fn method_prefix(self) -> &'static str {
         match self {
             TraitKind::Visit => "visit",
-            TraitKind::VisitAll => "visit",
             TraitKind::VisitMut => "visit_mut",
             TraitKind::Fold => "fold",
         }
@@ -274,7 +261,6 @@ impl TraitKind {
     pub fn trait_prefix(self) -> &'static str {
         match self {
             TraitKind::Visit => "Visit",
-            TraitKind::VisitAll => "VisitAll",
             TraitKind::VisitMut => "VisitMut",
             TraitKind::Fold => "Fold",
         }
@@ -326,7 +312,7 @@ impl Generator {
 
     fn method_lifetime(&self) -> TokenStream {
         match self.kind {
-            TraitKind::Visit | TraitKind::VisitAll => match self.variant {
+            TraitKind::Visit => match self.variant {
                 Variant::Normal => quote!(),
                 Variant::AstPath => quote!(<'ast: 'r, 'r>),
             },
@@ -337,7 +323,7 @@ impl Generator {
 
     fn parameter_type_token(&self, ty: TokenStream) -> TokenStream {
         match self.kind {
-            TraitKind::Visit | TraitKind::VisitAll => match self.variant {
+            TraitKind::Visit => match self.variant {
                 Variant::Normal => quote!(&#ty),
                 Variant::AstPath => quote!(&'ast #ty),
             },
@@ -349,7 +335,7 @@ impl Generator {
     /// This includes `->`
     fn return_type_token(&self, ty: TokenStream) -> TokenStream {
         match self.kind {
-            TraitKind::Visit | TraitKind::VisitAll => quote!(),
+            TraitKind::Visit => quote!(),
             TraitKind::VisitMut => quote!(),
             TraitKind::Fold => quote!(-> #ty),
         }
@@ -366,7 +352,7 @@ impl Generator {
         match self.variant {
             Variant::Normal => quote!(),
             Variant::AstPath => match self.kind {
-                TraitKind::Visit | TraitKind::VisitAll => {
+                TraitKind::Visit => {
                     quote!(, __ast_path: &mut AstNodePath<'r>)
                 }
                 TraitKind::VisitMut | TraitKind::Fold => quote!(, __ast_path: &mut AstKindPath),
@@ -412,7 +398,6 @@ impl Generator {
         let mut either_impl_methods = Vec::<TraitItem>::new();
         let mut optional_impl_methods = Vec::<TraitItem>::new();
         let mut ptr_impl_methods = Vec::<TraitItem>::new();
-        let mut visit_all_impl_methods = Vec::<TraitItem>::new();
 
         for ty in all_types {
             if let FieldType::Generic(name, ..) = &ty {
@@ -443,13 +428,7 @@ impl Generator {
                 Span::call_site(),
             );
 
-            let recurse_doc = match self.kind {
-                TraitKind::VisitAll => {
-                    "This method unconditionally calls the visitor method for all children because \
-                     it's defined in the trait [VisitAll]."
-                }
-                _ => "If you want to recurse, you need to call it manually.",
-            };
+            let recurse_doc = "If you want to recurse, you need to call it manually.";
 
             let method_doc = doc(&format!(
                 "Visit a node of type `{}`.\n\nBy default, this method calls \
@@ -501,17 +480,6 @@ impl Generator {
                     <V as #trait_name>::#visit_method_name(&mut **self, node #ast_path_arg)
                 }
             ));
-
-            if self.kind == TraitKind::Visit && self.variant == Variant::Normal {
-                visit_all_impl_methods.push(parse_quote!(
-                    #[inline]
-                    fn #visit_method_name #lifetime (&mut self, node: #type_param) #return_type {
-                        <V as VisitAll>::#visit_method_name(&mut self.visitor, node);
-
-                        <#node_type as #with_trait_name<Self>>::#visit_with_children_name(node, self);
-                    }
-                ));
-            }
         }
 
         items.push(parse_quote! {
@@ -563,20 +531,6 @@ impl Generator {
             }
         });
 
-        // ::swc_visit::All<V>
-
-        if self.kind == TraitKind::Visit {
-            items.push(parse_quote! {
-                #(#attrs)*
-                impl<V> #trait_name for ::swc_visit::All<V>
-                where
-                    V: VisitAll,
-                {
-                    #(#visit_all_impl_methods)*
-                }
-            });
-        }
-
         items
     }
 
@@ -784,7 +738,7 @@ impl Generator {
                 let mut stmts: Vec<Stmt> = Vec::new();
                 let mut bindings = Vec::new();
                 let mut reconstruct = match self.kind {
-                    TraitKind::Visit | TraitKind::VisitAll | TraitKind::VisitMut => None,
+                    TraitKind::Visit | TraitKind::VisitMut => None,
                     TraitKind::Fold => Some(Vec::<TokenStream>::new()),
                 };
 
@@ -799,10 +753,7 @@ impl Generator {
 
                     let mut ast_path_guard_expr: Option<Stmt> = None;
 
-                    if self.kind != TraitKind::VisitAll
-                        && self.variant == Variant::AstPath
-                        && !self.should_skip(ty)
-                    {
+                    if self.variant == Variant::AstPath && !self.should_skip(ty) {
                         let mut kind = quote!(self::fields::#fields_enum_name::#field_variant);
 
                         if extract_vec(extract_generic("Option", ty).unwrap_or(ty)).is_some() {
@@ -851,7 +802,7 @@ impl Generator {
                 }
 
                 match self.kind {
-                    TraitKind::Visit | TraitKind::VisitAll | TraitKind::VisitMut => {
+                    TraitKind::Visit | TraitKind::VisitMut => {
                         parse_quote!(#path { #(#bindings),* } => {
                             #enum_ast_path;
 
@@ -878,7 +829,7 @@ impl Generator {
                 let mut stmts: Vec<Stmt> = Vec::new();
                 let mut bindings = Vec::<TokenStream>::new();
                 let mut reconstruct = match self.kind {
-                    TraitKind::Visit | TraitKind::VisitAll | TraitKind::VisitMut => None,
+                    TraitKind::Visit | TraitKind::VisitMut => None,
                     TraitKind::Fold => Some(Vec::<TokenStream>::new()),
                 };
 
@@ -904,7 +855,7 @@ impl Generator {
                 }
 
                 match self.kind {
-                    TraitKind::Visit | TraitKind::VisitAll | TraitKind::VisitMut => {
+                    TraitKind::Visit | TraitKind::VisitMut => {
                         parse_quote!(#path { #(#bindings),* }=> {
                             #enum_ast_path;
 
@@ -925,7 +876,7 @@ impl Generator {
                 }
             }
             Fields::Unit => match self.kind {
-                TraitKind::Visit | TraitKind::VisitAll | TraitKind::VisitMut => {
+                TraitKind::Visit | TraitKind::VisitMut => {
                     parse_quote!(#path => {})
                 }
                 TraitKind::Fold => parse_quote!(#path => #path,),
@@ -981,7 +932,7 @@ impl Generator {
 
             let default_body: Expr = match node_type {
                 FieldType::Normal(..) => match self.kind {
-                    TraitKind::Visit | TraitKind::VisitAll => {
+                    TraitKind::Visit => {
                         parse_quote!({})
                     }
                     TraitKind::VisitMut => {
@@ -998,12 +949,12 @@ impl Generator {
                         let inner_ty = quote!(#inner);
 
                         match (self.kind, self.variant) {
-                            (TraitKind::Visit | TraitKind::VisitAll, Variant::Normal) => {
+                            (TraitKind::Visit, Variant::Normal) => {
                                 parse_quote!(self.iter().for_each(|item| {
                                     <#inner_ty as #visit_with_trait_name<V>>::#visit_with_name(item, visitor #ast_path_arg)
                                 }))
                             }
-                            (TraitKind::Visit | TraitKind::VisitAll, Variant::AstPath) => {
+                            (TraitKind::Visit, Variant::AstPath) => {
                                 parse_quote!(self.iter().enumerate().for_each(|(__idx, item)| {
                                     let mut __ast_path = __ast_path.with_index_guard(__idx);
                                     <#inner_ty as #visit_with_trait_name<V>>::#visit_with_name(item, visitor, &mut *__ast_path)
@@ -1046,7 +997,7 @@ impl Generator {
                         let inner_ty = quote!(#inner);
 
                         match self.kind {
-                            TraitKind::Visit | TraitKind::VisitAll => {
+                            TraitKind::Visit => {
                                 parse_quote!(
                                     match self {
                                         Some(inner) => {
@@ -1158,7 +1109,7 @@ impl Generator {
 
                 _ => {
                     let deref_expr = match self.kind {
-                        TraitKind::Visit | TraitKind::VisitAll => {
+                        TraitKind::Visit => {
                             quote!(&**self)
                         }
                         TraitKind::VisitMut => {
@@ -1170,7 +1121,7 @@ impl Generator {
                     };
 
                     let restore_expr = match self.kind {
-                        TraitKind::Visit | TraitKind::VisitAll => {
+                        TraitKind::Visit => {
                             quote!()
                         }
                         TraitKind::VisitMut => {
@@ -1204,7 +1155,7 @@ impl Generator {
             }
         }
 
-        if self.kind == TraitKind::Visit || self.kind == TraitKind::VisitAll {
+        if self.kind == TraitKind::Visit {
             // Vec<T> => [T]
             items.push(parse_quote!(
                 #(#attrs)*
@@ -1231,7 +1182,7 @@ impl Generator {
 
     fn node_type_for_visitor_method(&self, node_type: &FieldType) -> TokenStream {
         match self.kind {
-            TraitKind::Visit | TraitKind::VisitAll => match node_type {
+            TraitKind::Visit => match node_type {
                 FieldType::Generic(name, inner) if name == "Vec" => {
                     let inner_ty = quote!(#inner);